Skip to content

oshmem: sshmem: adds UCX allocator #2717

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 4 commits into from
Mar 9, 2017
Merged

oshmem: sshmem: adds UCX allocator #2717

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
4 commits
Select commit Hold shift + click to select a range
e038e3f
oshmem: sshmem: code cleaunp
alex-mikheev Jan 12, 2017
132fbd9
oshmem: sshmem: add UCX allocator
alex-mikheev Jan 15, 2017
c63137e
oshmem: sshmem ucx: minor code cleanup
alex-mikheev Jan 26, 2017
c9b5b12
oshmem: sshmem ucx: use fixed base address
alex-mikheev Feb 26, 2017
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
71 changes: 42 additions & 29 deletions oshmem/mca/spml/ucx/spml_ucx.c
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -420,45 +420,53 @@ sshmem_mkey_t *mca_spml_ucx_register(void* addr,
int *count)
{
sshmem_mkey_t *mkeys;
ucs_status_t err;
ucs_status_t status;
spml_ucx_mkey_t *ucx_mkey;
size_t len;
int my_pe = oshmem_my_proc_id();
ucp_mem_map_params_t mem_map_params;
int seg;
int segno;
map_segment_t *mem_seg;
unsigned flags;
int my_pe = oshmem_my_proc_id();

*count = 0;
mkeys = (sshmem_mkey_t *) calloc(1, sizeof(*mkeys));
if (!mkeys) {
return NULL;
}

seg = memheap_find_segnum(addr);
segno = memheap_find_segnum(addr);
Copy link
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

what if segno is invalid?

Copy link
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

It is always valid because the register function is only called for memory segments that were already allocated and belong to the memheap.

mem_seg = memheap_find_seg(segno);

ucx_mkey = &mca_spml_ucx.ucp_peers[my_pe].mkeys[seg].key;
ucx_mkey = &mca_spml_ucx.ucp_peers[my_pe].mkeys[segno].key;
mkeys[0].spml_context = ucx_mkey;

flags = 0;
if (mca_spml_ucx.heap_reg_nb && memheap_is_va_in_segment(addr, HEAP_SEG_INDEX)) {
flags = UCP_MEM_MAP_NONBLOCK;
}
/* if possible use mem handle already created by ucx allocator */
if (MAP_SEGMENT_ALLOC_UCX != mem_seg->type) {
flags = 0;
if (mca_spml_ucx.heap_reg_nb && memheap_is_va_in_segment(addr, HEAP_SEG_INDEX)) {
flags = UCP_MEM_MAP_NONBLOCK;
}

mem_map_params.field_mask = UCP_MEM_MAP_PARAM_FIELD_ADDRESS |
UCP_MEM_MAP_PARAM_FIELD_LENGTH |
UCP_MEM_MAP_PARAM_FIELD_FLAGS;
mem_map_params.address = addr;
mem_map_params.length = size;
mem_map_params.flags = flags;
mem_map_params.field_mask = UCP_MEM_MAP_PARAM_FIELD_ADDRESS |
UCP_MEM_MAP_PARAM_FIELD_LENGTH |
UCP_MEM_MAP_PARAM_FIELD_FLAGS;
mem_map_params.address = addr;
mem_map_params.length = size;
mem_map_params.flags = flags;

err = ucp_mem_map(mca_spml_ucx.ucp_context, &mem_map_params, &ucx_mkey->mem_h);
if (UCS_OK != err) {
goto error_out;
status = ucp_mem_map(mca_spml_ucx.ucp_context, &mem_map_params, &ucx_mkey->mem_h);
if (UCS_OK != status) {
goto error_out;
}

} else {
ucx_mkey->mem_h = (ucp_mem_h)mem_seg->context;
}

err = ucp_rkey_pack(mca_spml_ucx.ucp_context, ucx_mkey->mem_h,
&mkeys[0].u.data, &len);
if (UCS_OK != err) {
status = ucp_rkey_pack(mca_spml_ucx.ucp_context, ucx_mkey->mem_h,
&mkeys[0].u.data, &len);
if (UCS_OK != status) {
goto error_unmap;
}
if (len >= 0xffff) {
Expand All @@ -468,18 +476,18 @@ sshmem_mkey_t *mca_spml_ucx_register(void* addr,
oshmem_shmem_abort(-1);
}

err = ucp_ep_rkey_unpack(mca_spml_ucx.ucp_peers[oshmem_group_self->my_pe].ucp_conn,
mkeys[0].u.data,
&ucx_mkey->rkey);
if (UCS_OK != err) {
status = ucp_ep_rkey_unpack(mca_spml_ucx.ucp_peers[oshmem_group_self->my_pe].ucp_conn,
mkeys[0].u.data,
&ucx_mkey->rkey);
if (UCS_OK != status) {
SPML_ERROR("failed to unpack rkey");
goto error_unmap;
}

mkeys[0].len = len;
mkeys[0].va_base = mem_map_params.address;
mkeys[0].va_base = addr;
*count = 1;
mca_spml_ucx_cache_mkey(&mkeys[0], seg, my_pe);
mca_spml_ucx_cache_mkey(&mkeys[0], segno, my_pe);
return mkeys;

error_unmap:
Expand All @@ -493,6 +501,7 @@ sshmem_mkey_t *mca_spml_ucx_register(void* addr,
int mca_spml_ucx_deregister(sshmem_mkey_t *mkeys)
{
spml_ucx_mkey_t *ucx_mkey;
map_segment_t *mem_seg;

MCA_SPML_CALL(fence());
if (!mkeys)
Expand All @@ -501,8 +510,12 @@ int mca_spml_ucx_deregister(sshmem_mkey_t *mkeys)
if (!mkeys[0].spml_context)
return OSHMEM_SUCCESS;

ucx_mkey = (spml_ucx_mkey_t *)mkeys[0].spml_context;
ucp_mem_unmap(mca_spml_ucx.ucp_context, ucx_mkey->mem_h);
mem_seg = memheap_find_va(mkeys[0].va_base);

if (MAP_SEGMENT_ALLOC_UCX != mem_seg->type) {
ucx_mkey = (spml_ucx_mkey_t *)mkeys[0].spml_context;
ucp_mem_unmap(mca_spml_ucx.ucp_context, ucx_mkey->mem_h);
}

if (0 < mkeys[0].len) {
ucp_rkey_buffer_release(mkeys[0].u.data);
Expand Down
21 changes: 3 additions & 18 deletions oshmem/mca/sshmem/base/base.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -33,10 +33,6 @@ mca_sshmem_segment_create(map_segment_t *ds_buf,
const char *file_name,
size_t size);

OSHMEM_DECLSPEC int
mca_sshmem_ds_copy(const map_segment_t *from,
map_segment_t *to);

OSHMEM_DECLSPEC void *
mca_sshmem_segment_attach(map_segment_t *ds_buf, sshmem_mkey_t *mkey);

Expand Down Expand Up @@ -148,23 +144,12 @@ OSHMEM_DECLSPEC extern mca_base_framework_t oshmem_sshmem_base_framework;
"Warning %s:%d - %s()", __SSHMEM_FILE__, __LINE__, __func__, __VA_ARGS__)


OSHMEM_DECLSPEC extern void shmem_ds_reset(map_segment_t *ds_buf);

/*
* Get unique file name
*/
static inline char * oshmem_get_unique_file_name(uint64_t pe)
{
char *file_name = NULL;

assert(mca_sshmem_base_backing_file_dir);

if (NULL == (file_name = calloc(OPAL_PATH_MAX, sizeof(char)))) {
return NULL;
}

snprintf(file_name, OPAL_PATH_MAX, "%s/shmem_job_%u_pe_%llu", mca_sshmem_base_backing_file_dir, ORTE_PROC_MY_NAME->jobid, (unsigned long long)pe);

return file_name;
}
OSHMEM_DECLSPEC extern char * oshmem_get_unique_file_name(uint64_t pe);

END_C_DECLS

Expand Down
44 changes: 28 additions & 16 deletions oshmem/mca/sshmem/base/sshmem_base_wrappers.c
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -15,7 +15,6 @@
#include "oshmem/mca/sshmem/sshmem.h"
#include "oshmem/mca/sshmem/base/base.h"

/* ////////////////////////////////////////////////////////////////////////// */
int
mca_sshmem_segment_create(map_segment_t *ds_buf,
const char *file_name,
Expand All @@ -28,19 +27,6 @@ mca_sshmem_segment_create(map_segment_t *ds_buf,
return mca_sshmem_base_module->segment_create(ds_buf, file_name, size);
}

/* ////////////////////////////////////////////////////////////////////////// */
int
mca_sshmem_ds_copy(const map_segment_t *from,
map_segment_t *to)
{
if (!mca_sshmem_base_selected) {
return OSHMEM_ERROR;
}

return mca_sshmem_base_module->ds_copy(from, to);
}

/* ////////////////////////////////////////////////////////////////////////// */
void *
mca_sshmem_segment_attach(map_segment_t *ds_buf, sshmem_mkey_t *mkey)
{
Expand All @@ -51,7 +37,6 @@ mca_sshmem_segment_attach(map_segment_t *ds_buf, sshmem_mkey_t *mkey)
return mca_sshmem_base_module->segment_attach(ds_buf, mkey);
}

/* ////////////////////////////////////////////////////////////////////////// */
int
mca_sshmem_segment_detach(map_segment_t *ds_buf, sshmem_mkey_t *mkey)
{
Expand All @@ -62,7 +47,6 @@ mca_sshmem_segment_detach(map_segment_t *ds_buf, sshmem_mkey_t *mkey)
return mca_sshmem_base_module->segment_detach(ds_buf, mkey);
}

/* ////////////////////////////////////////////////////////////////////////// */
int
mca_sshmem_unlink(map_segment_t *ds_buf)
{
Expand All @@ -73,3 +57,31 @@ mca_sshmem_unlink(map_segment_t *ds_buf)
return mca_sshmem_base_module->unlink(ds_buf);
}


char * oshmem_get_unique_file_name(uint64_t pe)
{
char *file_name = NULL;

assert(mca_sshmem_base_backing_file_dir);

if (NULL == (file_name = calloc(OPAL_PATH_MAX, sizeof(char)))) {
return NULL;
}

snprintf(file_name, OPAL_PATH_MAX, "%s/shmem_job_%u_pe_%llu", mca_sshmem_base_backing_file_dir, ORTE_PROC_MY_NAME->jobid, (unsigned long long)pe);

return file_name;
}


void
shmem_ds_reset(map_segment_t *ds_buf)
{
MAP_SEGMENT_RESET_FLAGS(ds_buf);
ds_buf->seg_id = MAP_SEGMENT_SHM_INVALID;
ds_buf->super.va_base = 0;
ds_buf->super.va_end = 0;
ds_buf->seg_size = 0;
ds_buf->type = MAP_SEGMENT_UNKNOWN;
}

75 changes: 8 additions & 67 deletions oshmem/mca/sshmem/mmap/sshmem_mmap_module.c
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -64,10 +64,6 @@ segment_create(map_segment_t *ds_buf,
const char *file_name,
size_t size);

static int
ds_copy(const map_segment_t *from,
map_segment_t *to);

static void *
segment_attach(map_segment_t *ds_buf, sshmem_mkey_t *mkey);

Expand All @@ -88,44 +84,13 @@ mca_sshmem_mmap_module_t mca_sshmem_mmap_module = {
{
module_init,
segment_create,
ds_copy,
segment_attach,
segment_detach,
segment_unlink,
module_finalize
}
};

/* ////////////////////////////////////////////////////////////////////////// */
/* private utility functions */
/* ////////////////////////////////////////////////////////////////////////// */

/* ////////////////////////////////////////////////////////////////////////// */
/**
* completely resets the contents of *ds_buf
*/
static inline void
shmem_ds_reset(map_segment_t *ds_buf)
{
OPAL_OUTPUT_VERBOSE(
(70, oshmem_sshmem_base_framework.framework_output,
"%s: %s: shmem_ds_resetting "
"(id: %d, size: %lu, name: %s)\n",
mca_sshmem_mmap_component.super.base_version.mca_type_name,
mca_sshmem_mmap_component.super.base_version.mca_component_name,
ds_buf->seg_id, (unsigned long)ds_buf->seg_size, ds_buf->seg_name)
);

MAP_SEGMENT_RESET_FLAGS(ds_buf);
ds_buf->seg_id = MAP_SEGMENT_SHM_INVALID;
ds_buf->super.va_base = 0;
ds_buf->super.va_end = 0;
ds_buf->seg_size = 0;
ds_buf->type = MAP_SEGMENT_UNKNOWN;
unlink(ds_buf->seg_name);
memset(ds_buf->seg_name, '\0', sizeof(ds_buf->seg_name));
}

/* ////////////////////////////////////////////////////////////////////////// */
static int
module_init(void)
Expand All @@ -142,30 +107,6 @@ module_finalize(void)
return OSHMEM_SUCCESS;
}

/* ////////////////////////////////////////////////////////////////////////// */
static int
ds_copy(const map_segment_t *from,
map_segment_t *to)
{
memcpy(to, from, sizeof(map_segment_t));

OPAL_OUTPUT_VERBOSE(
(70, oshmem_sshmem_base_framework.framework_output,
"%s: %s: ds_copy complete "
"from: (id: %d, size: %lu, "
"name: %s flags: 0x%02x) "
"to: (id: %d, size: %lu, "
"name: %s flags: 0x%02x)\n",
mca_sshmem_mmap_component.super.base_version.mca_type_name,
mca_sshmem_mmap_component.super.base_version.mca_component_name,
from->seg_id, (unsigned long)from->seg_size, from->seg_name,
from->flags, to->seg_id, (unsigned long)to->seg_size, to->seg_name,
to->flags)
);

return OSHMEM_SUCCESS;
}
/* ////////////////////////////////////////////////////////////////////////// */

static int
segment_create(map_segment_t *ds_buf,
Expand Down Expand Up @@ -225,11 +166,11 @@ segment_create(map_segment_t *ds_buf,
OPAL_OUTPUT_VERBOSE(
(70, oshmem_sshmem_base_framework.framework_output,
"%s: %s: create %s "
"(id: %d, addr: %p size: %lu, name: %s)\n",
"(id: %d, addr: %p size: %lu)\n",
mca_sshmem_mmap_component.super.base_version.mca_type_name,
mca_sshmem_mmap_component.super.base_version.mca_component_name,
(rc ? "failure" : "successful"),
ds_buf->seg_id, ds_buf->super.va_base, (unsigned long)ds_buf->seg_size, ds_buf->seg_name)
ds_buf->seg_id, ds_buf->super.va_base, (unsigned long)ds_buf->seg_size)
);

return rc;
Expand Down Expand Up @@ -316,10 +257,10 @@ segment_attach(map_segment_t *ds_buf, sshmem_mkey_t *mkey)
OPAL_OUTPUT_VERBOSE(
(70, oshmem_sshmem_base_framework.framework_output,
"%s: %s: attach successful "
"(id: %d, addr: %p size: %lu, name: %s | va_base: 0x%p len: %d key %llx)\n",
"(id: %d, addr: %p size: %lu | va_base: 0x%p len: %d key %llx)\n",
mca_sshmem_mmap_component.super.base_version.mca_type_name,
mca_sshmem_mmap_component.super.base_version.mca_component_name,
ds_buf->seg_id, ds_buf->super.va_base, (unsigned long)ds_buf->seg_size, ds_buf->seg_name,
ds_buf->seg_id, ds_buf->super.va_base, (unsigned long)ds_buf->seg_size,
mkey->va_base, mkey->len, (unsigned long long)mkey->u.key)
);

Expand All @@ -338,10 +279,10 @@ segment_detach(map_segment_t *ds_buf, sshmem_mkey_t *mkey)
OPAL_OUTPUT_VERBOSE(
(70, oshmem_sshmem_base_framework.framework_output,
"%s: %s: detaching "
"(id: %d, addr: %p size: %lu, name: %s)\n",
"(id: %d, addr: %p size: %lu)\n",
mca_sshmem_mmap_component.super.base_version.mca_type_name,
mca_sshmem_mmap_component.super.base_version.mca_component_name,
ds_buf->seg_id, ds_buf->super.va_base, (unsigned long)ds_buf->seg_size, ds_buf->seg_name)
ds_buf->seg_id, ds_buf->super.va_base, (unsigned long)ds_buf->seg_size)
);

munmap((void *)ds_buf->super.va_base, ds_buf->seg_size);
Expand All @@ -363,10 +304,10 @@ segment_unlink(map_segment_t *ds_buf)
OPAL_OUTPUT_VERBOSE(
(70, oshmem_sshmem_base_framework.framework_output,
"%s: %s: unlinking "
"(id: %d, addr: %p size: %lu, name: %s)\n",
"(id: %d, addr: %p size: %lu)\n",
mca_sshmem_mmap_component.super.base_version.mca_type_name,
mca_sshmem_mmap_component.super.base_version.mca_component_name,
ds_buf->seg_id, ds_buf->super.va_base, (unsigned long)ds_buf->seg_size, ds_buf->seg_name)
ds_buf->seg_id, ds_buf->super.va_base, (unsigned long)ds_buf->seg_size)
);

/* don't completely reset. in particular, only reset
Expand Down
Loading