ports/openmpi
ports/openmpi
1
1
Форкнуть 0
Код Релизы Активность

clean up tab characters

Просмотр исходного кода 
This commit was SVN r25413.
Этот коммит содержится в:
Nathan Hjelm 2011-11-02 15:07:57 +00:00
родитель f00753881e
Коммит 211e2dbdf3
12 изменённых файлов: 407 добавлений и 407 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

330
ompi/mca/btl/vader/btl_vader.c
Просмотреть файл

@ -1,4 +1,4 @@
/* -*- Mode: C; c-basic-offset:4 ; -*- */ /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */
/* /*
* Copyright (c) 2004-2011 The Trustees of Indiana University and Indiana * Copyright (c) 2004-2011 The Trustees of Indiana University and Indiana
* University Research and Technology * University Research and Technology
@ -33,41 +33,41 @@
#include "btl_vader_fbox.h" #include "btl_vader_fbox.h"
static int vader_del_procs (struct mca_btl_base_module_t *btl, static int vader_del_procs (struct mca_btl_base_module_t *btl,
size_t nprocs, struct ompi_proc_t **procs, size_t nprocs, struct ompi_proc_t **procs,
struct mca_btl_base_endpoint_t **peers); struct mca_btl_base_endpoint_t **peers);
static int vader_register_error_cb (struct mca_btl_base_module_t* btl, static int vader_register_error_cb (struct mca_btl_base_module_t* btl,
mca_btl_base_module_error_cb_fn_t cbfunc); mca_btl_base_module_error_cb_fn_t cbfunc);
static int vader_finalize (struct mca_btl_base_module_t* btl); static int vader_finalize (struct mca_btl_base_module_t* btl);
static int vader_free (struct mca_btl_base_module_t* btl, mca_btl_base_descriptor_t* des); static int vader_free (struct mca_btl_base_module_t* btl, mca_btl_base_descriptor_t* des);
static struct mca_btl_base_descriptor_t *vader_prepare_src ( static struct mca_btl_base_descriptor_t *vader_prepare_src (
struct mca_btl_base_module_t *btl, struct mca_btl_base_module_t *btl,
struct mca_btl_base_endpoint_t *endpoint, struct mca_btl_base_endpoint_t *endpoint,
mca_mpool_base_registration_t *registration, mca_mpool_base_registration_t *registration,
struct opal_convertor_t *convertor, struct opal_convertor_t *convertor,
uint8_t order, uint8_t order,
size_t reserve, size_t reserve,
size_t *size, size_t *size,
uint32_t flags uint32_t flags
); );
static struct mca_btl_base_descriptor_t *vader_prepare_dst ( static struct mca_btl_base_descriptor_t *vader_prepare_dst (
struct mca_btl_base_module_t *btl, struct mca_btl_base_module_t *btl,
struct mca_btl_base_endpoint_t *endpoint, struct mca_btl_base_endpoint_t *endpoint,
struct mca_mpool_base_registration_t *registration, struct mca_mpool_base_registration_t *registration,
struct opal_convertor_t *convertor, struct opal_convertor_t *convertor,
uint8_t order, uint8_t order,
size_t reserve, size_t reserve,
size_t *size, size_t *size,
uint32_t flags); uint32_t flags);
static int vader_add_procs(struct mca_btl_base_module_t* btl, static int vader_add_procs(struct mca_btl_base_module_t* btl,
size_t nprocs, struct ompi_proc_t **procs, size_t nprocs, struct ompi_proc_t **procs,
struct mca_btl_base_endpoint_t** peers, struct mca_btl_base_endpoint_t** peers,
struct opal_bitmap_t* reachability); struct opal_bitmap_t* reachability);
static int vader_ft_event (int state); static int vader_ft_event (int state);
@ -93,7 +93,7 @@ mca_btl_vader_t mca_btl_vader = {
vader_prepare_src, vader_prepare_src,
vader_prepare_dst, vader_prepare_dst,
mca_btl_vader_send, mca_btl_vader_send,
mca_btl_vader_sendi, mca_btl_vader_sendi,
mca_btl_vader_put, mca_btl_vader_put,
mca_btl_vader_get, mca_btl_vader_get,
mca_btl_base_dump, mca_btl_base_dump,
@ -131,9 +131,9 @@ static void vader_init_maffinity (int *my_mem_node)
/* find core we are running on */ /* find core we are running on */
for (i = 0; i < num_core; ++i) { for (i = 0; i < num_core; ++i) {
if (OPAL_PAFFINITY_CPU_ISSET(i, cpus)) { if (OPAL_PAFFINITY_CPU_ISSET(i, cpus)) {
break; break;
} }
} }
if (OMPI_SUCCESS != opal_paffinity_base_get_map_to_socket_core(i, &socket, &i)) { if (OMPI_SUCCESS != opal_paffinity_base_get_map_to_socket_core(i, &socket, &i)) {
@ -146,17 +146,17 @@ static void vader_init_maffinity (int *my_mem_node)
slot_node = opal_carto_base_find_node(topo, myslot); slot_node = opal_carto_base_find_node(topo, myslot);
if (NULL == slot_node) { if (NULL == slot_node) {
goto out; goto out;
} }
opal_carto_base_get_nodes_distance(topo, slot_node, "Memory", &dists); opal_carto_base_get_nodes_distance(topo, slot_node, "Memory", &dists);
if (opal_value_array_get_size(&dists) > 1) { if (opal_value_array_get_size(&dists) > 1) {
dist = (opal_carto_node_distance_t *) opal_value_array_get_item(&dists, 0); dist = (opal_carto_node_distance_t *) opal_value_array_get_item(&dists, 0);
opal_maffinity_base_node_name_to_id(dist->node->node_name, my_mem_node); opal_maffinity_base_node_name_to_id(dist->node->node_name, my_mem_node);
} }
out: out:
if (myslot) { if (myslot) {
free(myslot); free(myslot);
} }
OBJ_DESTRUCT(&dists); OBJ_DESTRUCT(&dists);
@ -181,7 +181,7 @@ static inline int vader_init_mpool (mca_btl_vader_t *vader_btl, int n)
* in the allocator. * in the allocator.
*/ */
res.size = sizeof (vader_fifo_t) + 4 * opal_cache_line_size + res.size = sizeof (vader_fifo_t) + 4 * opal_cache_line_size +
(2 * n + component->vader_free_list_inc) * (component->eager_limit + 2 * opal_cache_line_size); (2 * n + component->vader_free_list_inc) * (component->eager_limit + 2 * opal_cache_line_size);
/* before we multiply by n, make sure the result won't overflow */ /* before we multiply by n, make sure the result won't overflow */
/* Stick that little pad in, particularly since we'll eventually /* Stick that little pad in, particularly since we'll eventually
@ -190,21 +190,21 @@ static inline int vader_init_mpool (mca_btl_vader_t *vader_btl, int n)
* added. * added.
*/ */
if ( ((double) res.size) * n > LONG_MAX - 4096 ) if ( ((double) res.size) * n > LONG_MAX - 4096 )
return OMPI_ERR_OUT_OF_RESOURCE; return OMPI_ERR_OUT_OF_RESOURCE;
res.size *= n; res.size *= n;
/* now, create it */ /* now, create it */
component->vader_mpool = component->vader_mpool =
mca_mpool_base_module_create(component->vader_mpool_name, mca_mpool_base_module_create(component->vader_mpool_name,
vader_btl, &res); vader_btl, &res);
/* Sanity check to ensure that we found it */ /* Sanity check to ensure that we found it */
if(NULL == component->vader_mpool) { if(NULL == component->vader_mpool) {
return OMPI_ERR_OUT_OF_RESOURCE; return OMPI_ERR_OUT_OF_RESOURCE;
} }
component->vader_mpool_base = component->vader_mpool_base =
component->vader_mpool->mpool_base (component->vader_mpool); component->vader_mpool->mpool_base (component->vader_mpool);
return OMPI_SUCCESS; return OMPI_SUCCESS;
} }
@ -222,14 +222,14 @@ static int vader_btl_first_time_init(mca_btl_vader_t *vader_btl, int n)
/* make the entire memory space of this process accessible */ /* make the entire memory space of this process accessible */
my_segid = xpmem_make (0, 0xffffffffffffffffll, XPMEM_PERMIT_MODE, my_segid = xpmem_make (0, 0xffffffffffffffffll, XPMEM_PERMIT_MODE,
(void *)0666); (void *)0666);
if (-1 == my_segid) { if (-1 == my_segid) {
return OMPI_ERROR; return OMPI_ERROR;
} }
rc = vader_init_mpool (vader_btl, n); rc = vader_init_mpool (vader_btl, n);
if (OMPI_SUCCESS != rc) { if (OMPI_SUCCESS != rc) {
return rc; return rc;
} }
/* create a list of peers */ /* create a list of peers */
@ -251,7 +251,7 @@ static int vader_btl_first_time_init(mca_btl_vader_t *vader_btl, int n)
segment (only the shared control structure) */ segment (only the shared control structure) */
size = sizeof (mca_common_sm_seg_header_t) + size = sizeof (mca_common_sm_seg_header_t) +
n * (sizeof (vader_fifo_t *) + sizeof (char *) n * (sizeof (vader_fifo_t *) + sizeof (char *)
+ sizeof (xpmem_segid_t)) + opal_cache_line_size; + sizeof (xpmem_segid_t)) + opal_cache_line_size;
procs = ompi_proc_world(&num_procs); procs = ompi_proc_world(&num_procs);
if (!(mca_btl_vader_component.vader_seg = if (!(mca_btl_vader_component.vader_seg =
mca_common_sm_init(procs, num_procs, size, vader_ctl_file, mca_common_sm_init(procs, num_procs, size, vader_ctl_file,
@ -287,40 +287,40 @@ static int vader_btl_first_time_init(mca_btl_vader_t *vader_btl, int n)
return OMPI_ERR_OUT_OF_RESOURCE; return OMPI_ERR_OUT_OF_RESOURCE;
component->shm_fifo[component->my_smp_rank] = component->shm_fifo[component->my_smp_rank] =
component->fifo[component->my_smp_rank] = my_fifos; component->fifo[component->my_smp_rank] = my_fifos;
component->apids = (xpmem_apid_t *) calloc (n, sizeof (xpmem_apid_t)); component->apids = (xpmem_apid_t *) calloc (n, sizeof (xpmem_apid_t));
if (NULL == component->apids) if (NULL == component->apids)
return OMPI_ERR_OUT_OF_RESOURCE; return OMPI_ERR_OUT_OF_RESOURCE;
component->xpmem_rcaches = component->xpmem_rcaches =
(struct mca_rcache_base_module_t **) calloc (n, sizeof (struct mca_rcache_base_module_t *)); (struct mca_rcache_base_module_t **) calloc (n, sizeof (struct mca_rcache_base_module_t *));
if (NULL == component->xpmem_rcaches) if (NULL == component->xpmem_rcaches)
return OMPI_ERR_OUT_OF_RESOURCE; return OMPI_ERR_OUT_OF_RESOURCE;
component->vader_fboxes_in = (char **) calloc (n, sizeof (char *)); component->vader_fboxes_in = (char **) calloc (n, sizeof (char *));
if (NULL == component->vader_fboxes_in) if (NULL == component->vader_fboxes_in)
return OMPI_ERR_OUT_OF_RESOURCE; return OMPI_ERR_OUT_OF_RESOURCE;
component->vader_fboxes_out = (char **) calloc (n, sizeof (char *)); component->vader_fboxes_out = (char **) calloc (n, sizeof (char *));
if (NULL == component->vader_fboxes_out) if (NULL == component->vader_fboxes_out)
return OMPI_ERR_OUT_OF_RESOURCE; return OMPI_ERR_OUT_OF_RESOURCE;
component->vader_next_fbox_in = (unsigned char *) calloc (64, 1); component->vader_next_fbox_in = (unsigned char *) calloc (64, 1);
if (NULL == component->vader_next_fbox_in) if (NULL == component->vader_next_fbox_in)
return OMPI_ERR_OUT_OF_RESOURCE; return OMPI_ERR_OUT_OF_RESOURCE;
component->vader_next_fbox_out = (unsigned char *) calloc (64, 1); component->vader_next_fbox_out = (unsigned char *) calloc (64, 1);
if (NULL == component->vader_next_fbox_out) if (NULL == component->vader_next_fbox_out)
return OMPI_ERR_OUT_OF_RESOURCE; return OMPI_ERR_OUT_OF_RESOURCE;
/* initialize fragment descriptor free lists */ /* initialize fragment descriptor free lists */
/* initialize free list for send fragments */ /* initialize free list for send fragments */
i = ompi_free_list_init_new(&component->vader_frags_eager, i = ompi_free_list_init_new(&component->vader_frags_eager,
sizeof (mca_btl_vader_frag_t), sizeof (mca_btl_vader_frag_t),
opal_cache_line_size, OBJ_CLASS(mca_btl_vader_frag_t), opal_cache_line_size, OBJ_CLASS(mca_btl_vader_frag_t),
sizeof (mca_btl_vader_hdr_t) + component->eager_limit, sizeof (mca_btl_vader_hdr_t) + component->eager_limit,
opal_cache_line_size, opal_cache_line_size,
component->vader_free_list_num, component->vader_free_list_num,
component->vader_free_list_max, component->vader_free_list_max,
component->vader_free_list_inc, component->vader_free_list_inc,
@ -330,16 +330,16 @@ static int vader_btl_first_time_init(mca_btl_vader_t *vader_btl, int n)
/* initialize free list for put/get fragments */ /* initialize free list for put/get fragments */
i = ompi_free_list_init_new(&component->vader_frags_user, i = ompi_free_list_init_new(&component->vader_frags_user,
sizeof(mca_btl_vader_frag_t), sizeof(mca_btl_vader_frag_t),
opal_cache_line_size, OBJ_CLASS(mca_btl_vader_frag_t), opal_cache_line_size, OBJ_CLASS(mca_btl_vader_frag_t),
sizeof(mca_btl_vader_hdr_t) + mca_btl_vader_max_inline_send, sizeof(mca_btl_vader_hdr_t) + mca_btl_vader_max_inline_send,
opal_cache_line_size, opal_cache_line_size,
component->vader_free_list_num, component->vader_free_list_num,
component->vader_free_list_max, component->vader_free_list_max,
component->vader_free_list_inc, component->vader_free_list_inc,
component->vader_mpool); component->vader_mpool);
if (OMPI_SUCCESS != i) if (OMPI_SUCCESS != i)
return i; return i;
/* set flag indicating btl has been inited */ /* set flag indicating btl has been inited */
vader_btl->btl_inited = true; vader_btl->btl_inited = true;
@ -353,7 +353,7 @@ mca_btl_base_endpoint_t *create_vader_endpoint (int local_proc, struct ompi_proc
struct mca_btl_base_endpoint_t *ep = (struct mca_btl_base_endpoint_t *) struct mca_btl_base_endpoint_t *ep = (struct mca_btl_base_endpoint_t *)
calloc(1, sizeof (struct mca_btl_base_endpoint_t)); calloc(1, sizeof (struct mca_btl_base_endpoint_t));
if(NULL != ep) { if(NULL != ep) {
ep->peer_smp_rank = local_proc + mca_btl_vader_component.num_smp_procs; ep->peer_smp_rank = local_proc + mca_btl_vader_component.num_smp_procs;
} }
return ep; return ep;
@ -374,9 +374,9 @@ mca_btl_base_endpoint_t *create_vader_endpoint (int local_proc, struct ompi_proc
*/ */
static int vader_add_procs (struct mca_btl_base_module_t* btl, static int vader_add_procs (struct mca_btl_base_module_t* btl,
size_t nprocs, struct ompi_proc_t **procs, size_t nprocs, struct ompi_proc_t **procs,
struct mca_btl_base_endpoint_t **peers, struct mca_btl_base_endpoint_t **peers,
opal_bitmap_t *reachability) opal_bitmap_t *reachability)
{ {
mca_btl_vader_component_t *component = &mca_btl_vader_component; mca_btl_vader_component_t *component = &mca_btl_vader_component;
mca_btl_vader_t *vader_btl = (mca_btl_vader_t *) btl; mca_btl_vader_t *vader_btl = (mca_btl_vader_t *) btl;
@ -408,7 +408,7 @@ static int vader_add_procs (struct mca_btl_base_module_t* btl,
/* check to see if this is me */ /* check to see if this is me */
if (my_proc == procs[proc]) { if (my_proc == procs[proc]) {
my_smp_rank = component->my_smp_rank = n_local_procs++; my_smp_rank = component->my_smp_rank = n_local_procs++;
continue; continue;
} }
/* we have someone to talk to */ /* we have someone to talk to */
@ -424,7 +424,7 @@ static int vader_add_procs (struct mca_btl_base_module_t* btl,
rc = opal_bitmap_set_bit (reachability, proc); rc = opal_bitmap_set_bit (reachability, proc);
if(OMPI_SUCCESS != rc) { if(OMPI_SUCCESS != rc) {
goto CLEANUP; goto CLEANUP;
} }
} }
/* jump out if there's not someone we can talk to */ /* jump out if there's not someone we can talk to */
@ -442,7 +442,7 @@ static int vader_add_procs (struct mca_btl_base_module_t* btl,
rc = vader_btl_first_time_init(vader_btl, n_local_procs); rc = vader_btl_first_time_init(vader_btl, n_local_procs);
if(rc != OMPI_SUCCESS) { if(rc != OMPI_SUCCESS) {
goto CLEANUP; goto CLEANUP;
} }
} }
/* set local proc's smp rank in the peers structure for /* set local proc's smp rank in the peers structure for
@ -462,7 +462,7 @@ static int vader_add_procs (struct mca_btl_base_module_t* btl,
*/ */
rc = vader_fifo_init (component->fifo[my_smp_rank]); rc = vader_fifo_init (component->fifo[my_smp_rank]);
if (OMPI_SUCCESS != rc) { if (OMPI_SUCCESS != rc) {
goto CLEANUP; goto CLEANUP;
} }
opal_atomic_wmb(); opal_atomic_wmb();
@ -479,7 +479,7 @@ static int vader_add_procs (struct mca_btl_base_module_t* btl,
/* coordinate with other processes */ /* coordinate with other processes */
for (i = 0 ; i < n_local_procs ; ++i) { for (i = 0 ; i < n_local_procs ; ++i) {
int peer_smp_rank = i + component->num_smp_procs; int peer_smp_rank = i + component->num_smp_procs;
/* spin until this element is allocated */ /* spin until this element is allocated */
/* doesn't really wait for that process... FIFO might be allocated, but not initialized */ /* doesn't really wait for that process... FIFO might be allocated, but not initialized */
@ -488,31 +488,31 @@ static int vader_add_procs (struct mca_btl_base_module_t* btl,
opal_atomic_rmb(); opal_atomic_rmb();
} }
if (my_smp_rank != peer_smp_rank) { if (my_smp_rank != peer_smp_rank) {
void *rem_ptr = (void *) component->shm_fifo[peer_smp_rank]; void *rem_ptr = (void *) component->shm_fifo[peer_smp_rank];
component->apids[peer_smp_rank] = component->apids[peer_smp_rank] =
xpmem_get (component->shm_seg_ids[peer_smp_rank], xpmem_get (component->shm_seg_ids[peer_smp_rank],
XPMEM_RDWR, XPMEM_PERMIT_MODE, (void *) 0666); XPMEM_RDWR, XPMEM_PERMIT_MODE, (void *) 0666);
component->xpmem_rcaches[peer_smp_rank] = mca_rcache_base_module_create("vma"); component->xpmem_rcaches[peer_smp_rank] = mca_rcache_base_module_create("vma");
/* get a persistent pointer to the peer's fifo */ /* get a persistent pointer to the peer's fifo */
component->fifo[peer_smp_rank] = component->fifo[peer_smp_rank] =
vader_reg_to_ptr (vader_get_registation (peer_smp_rank, rem_ptr, vader_reg_to_ptr (vader_get_registation (peer_smp_rank, rem_ptr,
(n_local_procs + 1) * getpagesize (), (n_local_procs + 1) * getpagesize (),
MCA_MPOOL_FLAGS_PERSIST), rem_ptr); MCA_MPOOL_FLAGS_PERSIST), rem_ptr);
/* fast boxes are allocated at the same time as the fifos */ /* fast boxes are allocated at the same time as the fifos */
component->vader_fboxes_in[peer_smp_rank] = (char *) component->fifo[my_smp_rank] + component->vader_fboxes_in[peer_smp_rank] = (char *) component->fifo[my_smp_rank] +
(peer_smp_rank + 1) * getpagesize (); (peer_smp_rank + 1) * getpagesize ();
component->vader_fboxes_out[peer_smp_rank] = (char *) component->fifo[peer_smp_rank] + component->vader_fboxes_out[peer_smp_rank] = (char *) component->fifo[peer_smp_rank] +
(my_smp_rank + 1) * getpagesize (); (my_smp_rank + 1) * getpagesize ();
component->vader_next_fbox_in[peer_smp_rank] = 0; component->vader_next_fbox_in[peer_smp_rank] = 0;
component->vader_next_fbox_out[peer_smp_rank] = 0; component->vader_next_fbox_out[peer_smp_rank] = 0;
memset (component->vader_fboxes_in[peer_smp_rank], MCA_BTL_VADER_FBOX_FREE, getpagesize()); memset (component->vader_fboxes_in[peer_smp_rank], MCA_BTL_VADER_FBOX_FREE, getpagesize());
} }
} }
/* update the local smp process count */ /* update the local smp process count */
@ -520,7 +520,7 @@ static int vader_add_procs (struct mca_btl_base_module_t* btl,
/* make sure we have enough eager fragmnents for each process */ /* make sure we have enough eager fragmnents for each process */
rc = ompi_free_list_resize(&component->vader_frags_eager, rc = ompi_free_list_resize(&component->vader_frags_eager,
component->num_smp_procs * 2); component->num_smp_procs * 2);
CLEANUP: CLEANUP:
@ -538,8 +538,8 @@ static int vader_add_procs (struct mca_btl_base_module_t* btl,
*/ */
static int vader_del_procs(struct mca_btl_base_module_t *btl, static int vader_del_procs(struct mca_btl_base_module_t *btl,
size_t nprocs, struct ompi_proc_t **procs, size_t nprocs, struct ompi_proc_t **procs,
struct mca_btl_base_endpoint_t **peers) struct mca_btl_base_endpoint_t **peers)
{ {
return OMPI_SUCCESS; return OMPI_SUCCESS;
} }
@ -572,7 +572,7 @@ static int vader_finalize(struct mca_btl_base_module_t *btl)
* @return Status indicating if cleanup was successful * @return Status indicating if cleanup was successful
*/ */
static int vader_register_error_cb(struct mca_btl_base_module_t* btl, static int vader_register_error_cb(struct mca_btl_base_module_t* btl,
mca_btl_base_module_error_cb_fn_t cbfunc) mca_btl_base_module_error_cb_fn_t cbfunc)
{ {
((mca_btl_vader_t *)btl)->error_cb = cbfunc; ((mca_btl_vader_t *)btl)->error_cb = cbfunc;
return OMPI_SUCCESS; return OMPI_SUCCESS;
@ -585,28 +585,28 @@ static int vader_register_error_cb(struct mca_btl_base_module_t* btl,
* @param size (IN) Request segment size. * @param size (IN) Request segment size.
*/ */
mca_btl_base_descriptor_t *mca_btl_vader_alloc(struct mca_btl_base_module_t *btl, mca_btl_base_descriptor_t *mca_btl_vader_alloc(struct mca_btl_base_module_t *btl,
struct mca_btl_base_endpoint_t *endpoint, struct mca_btl_base_endpoint_t *endpoint,
uint8_t order, size_t size, uint32_t flags) uint8_t order, size_t size, uint32_t flags)
{ {
mca_btl_vader_frag_t *frag = NULL; mca_btl_vader_frag_t *frag = NULL;
int rc; int rc;
if (size <= mca_btl_vader_max_inline_send) { if (size <= mca_btl_vader_max_inline_send) {
MCA_BTL_VADER_FRAG_ALLOC_USER(frag, rc); MCA_BTL_VADER_FRAG_ALLOC_USER(frag, rc);
} else if (size <= mca_btl_vader_component.eager_limit) { } else if (size <= mca_btl_vader_component.eager_limit) {
MCA_BTL_VADER_FRAG_ALLOC_EAGER(frag, rc); MCA_BTL_VADER_FRAG_ALLOC_EAGER(frag, rc);
} }
if (OPAL_LIKELY(frag != NULL)) { if (OPAL_LIKELY(frag != NULL)) {
frag->segment.seg_len = size; frag->segment.seg_len = size;
frag->endpoint = endpoint; frag->endpoint = endpoint;
frag->base.des_flags = flags; frag->base.des_flags = flags;
frag->base.order = order; frag->base.order = order;
frag->base.des_src = &frag->segment; frag->base.des_src = &frag->segment;
frag->base.des_src_cnt = 1; frag->base.des_src_cnt = 1;
frag->base.des_dst = &frag->segment; frag->base.des_dst = &frag->segment;
frag->base.des_src_cnt = 1; frag->base.des_src_cnt = 1;
} }
return (mca_btl_base_descriptor_t *) frag; return (mca_btl_base_descriptor_t *) frag;
@ -626,11 +626,11 @@ static int vader_free (struct mca_btl_base_module_t *btl, mca_btl_base_descripto
} }
struct mca_btl_base_descriptor_t *vader_prepare_dst(struct mca_btl_base_module_t *btl, struct mca_btl_base_descriptor_t *vader_prepare_dst(struct mca_btl_base_module_t *btl,
struct mca_btl_base_endpoint_t *endpoint, struct mca_btl_base_endpoint_t *endpoint,
struct mca_mpool_base_registration_t *registration, struct mca_mpool_base_registration_t *registration,
struct opal_convertor_t *convertor, struct opal_convertor_t *convertor,
uint8_t order, size_t reserve, size_t *size, uint8_t order, size_t reserve, size_t *size,
uint32_t flags) uint32_t flags)
{ {
mca_btl_vader_frag_t *frag; mca_btl_vader_frag_t *frag;
void *data_ptr; void *data_ptr;
@ -662,11 +662,11 @@ struct mca_btl_base_descriptor_t *vader_prepare_dst(struct mca_btl_base_module_t
* @param btl (IN) BTL module * @param btl (IN) BTL module
*/ */
static struct mca_btl_base_descriptor_t *vader_prepare_src (struct mca_btl_base_module_t *btl, static struct mca_btl_base_descriptor_t *vader_prepare_src (struct mca_btl_base_module_t *btl,
struct mca_btl_base_endpoint_t *endpoint, struct mca_btl_base_endpoint_t *endpoint,
mca_mpool_base_registration_t *registration, mca_mpool_base_registration_t *registration,
struct opal_convertor_t *convertor, struct opal_convertor_t *convertor,
uint8_t order, size_t reserve, size_t *size, uint8_t order, size_t reserve, size_t *size,
uint32_t flags) uint32_t flags)
{ {
struct iovec iov, *lcl_mem; struct iovec iov, *lcl_mem;
mca_btl_vader_frag_t *frag; mca_btl_vader_frag_t *frag;
@ -677,69 +677,69 @@ static struct mca_btl_base_descriptor_t *vader_prepare_src (struct mca_btl_base_
opal_convertor_get_current_pointer (convertor, &data_ptr); opal_convertor_get_current_pointer (convertor, &data_ptr);
if (OPAL_LIKELY(reserve)) { if (OPAL_LIKELY(reserve)) {
/* in place send fragment */ /* in place send fragment */
if (OPAL_UNLIKELY(opal_convertor_need_buffers(convertor))) { if (OPAL_UNLIKELY(opal_convertor_need_buffers(convertor))) {
/* non-contiguous data requires the convertor */ /* non-contiguous data requires the convertor */
MCA_BTL_VADER_FRAG_ALLOC_EAGER(frag,rc); MCA_BTL_VADER_FRAG_ALLOC_EAGER(frag,rc);
if (OPAL_UNLIKELY(NULL == frag)) { if (OPAL_UNLIKELY(NULL == frag)) {
return NULL; return NULL;
} }
iov.iov_len = mca_btl_vader_component.eager_limit - reserve; iov.iov_len = mca_btl_vader_component.eager_limit - reserve;
iov.iov_base = iov.iov_base =
(IOVBASE_TYPE *)(((uintptr_t)(frag->segment.seg_addr.pval)) + (IOVBASE_TYPE *)(((uintptr_t)(frag->segment.seg_addr.pval)) +
reserve); reserve);
rc = opal_convertor_pack (convertor, &iov, &iov_count, size); rc = opal_convertor_pack (convertor, &iov, &iov_count, size);
if (OPAL_UNLIKELY(rc < 0)) { if (OPAL_UNLIKELY(rc < 0)) {
MCA_BTL_VADER_FRAG_RETURN(frag); MCA_BTL_VADER_FRAG_RETURN(frag);
return NULL; return NULL;
} }
frag->segment.seg_len = reserve + *size; frag->segment.seg_len = reserve + *size;
} else { } else {
MCA_BTL_VADER_FRAG_ALLOC_USER(frag, rc); MCA_BTL_VADER_FRAG_ALLOC_USER(frag, rc);
if (OPAL_UNLIKELY(NULL == frag)) { if (OPAL_UNLIKELY(NULL == frag)) {
return NULL; return NULL;
} }
if ((*size + reserve) > mca_btl_vader_max_inline_send) { if ((*size + reserve) > mca_btl_vader_max_inline_send) {
/* single copy send */ /* single copy send */
/* pack the iovec after the reserved memory */ /* pack the iovec after the reserved memory */
lcl_mem = (struct iovec *) ((uintptr_t)frag->segment.seg_addr.pval + reserve); lcl_mem = (struct iovec *) ((uintptr_t)frag->segment.seg_addr.pval + reserve);
frag->hdr->flags = MCA_BTL_VADER_FLAG_SINGLE_COPY; frag->hdr->flags = MCA_BTL_VADER_FLAG_SINGLE_COPY;
lcl_mem->iov_base = data_ptr; lcl_mem->iov_base = data_ptr;
lcl_mem->iov_len = *size; lcl_mem->iov_len = *size;
frag->segment.seg_len = reserve; frag->segment.seg_len = reserve;
} else { } else {
/* inline send */ /* inline send */
/* try to reserve a fast box for this transfer */ /* try to reserve a fast box for this transfer */
fbox_ptr = mca_btl_vader_reserve_fbox (endpoint->peer_smp_rank, reserve + *size); fbox_ptr = mca_btl_vader_reserve_fbox (endpoint->peer_smp_rank, reserve + *size);
if (fbox_ptr) { if (fbox_ptr) {
frag->hdr->flags |= MCA_BTL_VADER_FLAG_FBOX; frag->hdr->flags |= MCA_BTL_VADER_FLAG_FBOX;
frag->segment.seg_addr.pval = fbox_ptr; frag->segment.seg_addr.pval = fbox_ptr;
} }
/* NTH: the covertor adds some latency so we bypass it here */ /* NTH: the covertor adds some latency so we bypass it here */
vader_memmove ((void *)((uintptr_t)frag->segment.seg_addr.pval + reserve), vader_memmove ((void *)((uintptr_t)frag->segment.seg_addr.pval + reserve),
data_ptr, *size); data_ptr, *size);
frag->segment.seg_len = reserve + *size; frag->segment.seg_len = reserve + *size;
} }
} }
} else { } else {
/* put/get fragment */ /* put/get fragment */
MCA_BTL_VADER_FRAG_ALLOC_USER(frag, rc); MCA_BTL_VADER_FRAG_ALLOC_USER(frag, rc);
if (OPAL_UNLIKELY(NULL == frag)) { if (OPAL_UNLIKELY(NULL == frag)) {
return NULL; return NULL;
} }
frag->segment.seg_key.ptr = (uintptr_t) data_ptr; frag->segment.seg_key.ptr = (uintptr_t) data_ptr;
frag->segment.seg_len = reserve + *size; frag->segment.seg_len = reserve + *size;
} }
frag->base.des_src = &frag->segment; frag->base.des_src = &frag->segment;

138
ompi/mca/btl/vader/btl_vader.h
Просмотреть файл

@ -1,4 +1,4 @@
/* -*- Mode: C; c-basic-offset:4 ; -*- */ /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */
/* /*
* Copyright (c) 2004-2007 The Trustees of Indiana University and Indiana * Copyright (c) 2004-2007 The Trustees of Indiana University and Indiana
* University Research and Technology * University Research and Technology
@ -91,19 +91,19 @@ struct mca_btl_vader_component_t {
int vader_free_list_num; /**< initial size of free lists */ int vader_free_list_num; /**< initial size of free lists */
int vader_free_list_max; /**< maximum size of free lists */ int vader_free_list_max; /**< maximum size of free lists */
int vader_free_list_inc; /**< number of elements to alloc int vader_free_list_inc; /**< number of elements to alloc
* when growing free lists */ * when growing free lists */
char *vader_mpool_name; /**< name of shared memory pool module */ char *vader_mpool_name; /**< name of shared memory pool module */
mca_mpool_base_module_t *vader_mpool; /**< mpool on local node */ mca_mpool_base_module_t *vader_mpool; /**< mpool on local node */
void *vader_mpool_base; /**< base address of shared memory pool */ void *vader_mpool_base; /**< base address of shared memory pool */
size_t eager_limit; /**< send fragment size */ size_t eager_limit; /**< send fragment size */
mca_common_sm_module_t *vader_seg; /**< description of shared memory segment */ mca_common_sm_module_t *vader_seg; /**< description of shared memory segment */
volatile struct vader_fifo_t **shm_fifo;/**< pointer to fifo 2D array in volatile struct vader_fifo_t **shm_fifo;/**< pointer to fifo 2D array in
* shared memory */ * shared memory */
char **shm_bases; /**< pointer to base pointers in char **shm_bases; /**< pointer to base pointers in
* shared memory */ * shared memory */
xpmem_segid_t *shm_seg_ids; /* xpmem segment ids */ xpmem_segid_t *shm_seg_ids; /* xpmem segment ids */
struct vader_fifo_t **fifo; /**< cached copy of the pointer to struct vader_fifo_t **fifo; /**< cached copy of the pointer to
* the 2D fifo array. */ * the 2D fifo array. */
struct mca_rcache_base_module_t **xpmem_rcaches; struct mca_rcache_base_module_t **xpmem_rcaches;
xpmem_apid_t *apids; /* xpmem apids */ xpmem_apid_t *apids; /* xpmem apids */
int32_t num_smp_procs; /**< current number of smp procs on this host */ int32_t num_smp_procs; /**< current number of smp procs on this host */
@ -161,7 +161,7 @@ static inline uintptr_t get_mask (uintptr_t x)
/* look up the remote pointer in the peer rcache and attach if /* look up the remote pointer in the peer rcache and attach if
* necessary */ * necessary */
static inline mca_mpool_base_registration_t *vader_get_registation (int peer_smp_rank, void *rem_ptr, static inline mca_mpool_base_registration_t *vader_get_registation (int peer_smp_rank, void *rem_ptr,
size_t size, int flags) size_t size, int flags)
{ {
struct mca_rcache_base_module_t *rcache = mca_btl_vader_component.xpmem_rcaches[peer_smp_rank]; struct mca_rcache_base_module_t *rcache = mca_btl_vader_component.xpmem_rcaches[peer_smp_rank];
mca_mpool_base_registration_t *regs[10], *reg = NULL; mca_mpool_base_registration_t *regs[10], *reg = NULL;
@ -170,75 +170,75 @@ static inline mca_mpool_base_registration_t *vader_get_registation (int peer_smp
int rc, i; int rc, i;
if (OPAL_UNLIKELY(peer_smp_rank == mca_btl_vader_component.my_smp_rank)) { if (OPAL_UNLIKELY(peer_smp_rank == mca_btl_vader_component.my_smp_rank)) {
return rem_ptr; return rem_ptr;
} }
mask = get_mask (mca_btl_vader_segment_multiple); mask = get_mask (mca_btl_vader_segment_multiple);
base = (uintptr_t) down_align_addr(rem_ptr, mca_mpool_base_page_size_log); base = (uintptr_t) down_align_addr(rem_ptr, mca_mpool_base_page_size_log);
bound = (uintptr_t) up_align_addr((void *)((uintptr_t) rem_ptr + size - 1), bound = (uintptr_t) up_align_addr((void *)((uintptr_t) rem_ptr + size - 1),
mca_mpool_base_page_size_log) + 1; mca_mpool_base_page_size_log) + 1;
/* several segments may match the base pointer */ /* several segments may match the base pointer */
rc = rcache->rcache_find_all (rcache, (void *) base, bound - base, regs, 10); rc = rcache->rcache_find_all (rcache, (void *) base, bound - base, regs, 10);
for (i = 0 ; i < rc ; ++i) { for (i = 0 ; i < rc ; ++i) {
if (bound <= (uintptr_t)regs[i]->bound && base >= (uintptr_t)regs[i]->base) { if (bound <= (uintptr_t)regs[i]->bound && base >= (uintptr_t)regs[i]->base) {
opal_atomic_add (&regs[i]->ref_count, 1); opal_atomic_add (&regs[i]->ref_count, 1);
return regs[i]; return regs[i];
} }
if (regs[i]->flags & MCA_MPOOL_FLAGS_PERSIST) { if (regs[i]->flags & MCA_MPOOL_FLAGS_PERSIST) {
continue; continue;
} }
/* remove this pointer from the rcache and decrement its reference count /* remove this pointer from the rcache and decrement its reference count
(so it is detached later) */ (so it is detached later) */
rc = rcache->rcache_delete (rcache, regs[i]); rc = rcache->rcache_delete (rcache, regs[i]);
if (OPAL_UNLIKELY(0 != rc)) { if (OPAL_UNLIKELY(0 != rc)) {
/* someone beat us to it? */ /* someone beat us to it? */
break; break;
} }
/* start the new segment from the lower of the two bases */ /* start the new segment from the lower of the two bases */
base = (uintptr_t) regs[i]->base < base ? (uintptr_t) regs[i]->base : base; base = (uintptr_t) regs[i]->base < base ? (uintptr_t) regs[i]->base : base;
opal_atomic_add (&regs[i]->ref_count, -1); opal_atomic_add (&regs[i]->ref_count, -1);
if (OPAL_LIKELY(0 == regs[i]->ref_count)) { if (OPAL_LIKELY(0 == regs[i]->ref_count)) {
/* this pointer is not in use */ /* this pointer is not in use */
(void) xpmem_detach (regs[i]->alloc_base); (void) xpmem_detach (regs[i]->alloc_base);
OBJ_RELEASE(regs[i]); OBJ_RELEASE(regs[i]);
} }
break; break;
} }
if ((ptrdiff_t) (bound - base) & mask) { if ((ptrdiff_t) (bound - base) & mask) {
bound = base + ((bound - base) & ~mask) + mca_btl_vader_segment_multiple; bound = base + ((bound - base) & ~mask) + mca_btl_vader_segment_multiple;
} }
if (OPAL_UNLIKELY(bound > VADER_MAX_ADDRESS)) { if (OPAL_UNLIKELY(bound > VADER_MAX_ADDRESS)) {
bound = VADER_MAX_ADDRESS; bound = VADER_MAX_ADDRESS;
} }
reg = OBJ_NEW(mca_mpool_base_registration_t); reg = OBJ_NEW(mca_mpool_base_registration_t);
if (OPAL_UNLIKELY(NULL != reg)) { if (OPAL_UNLIKELY(NULL != reg)) {
/* stick around for awhile */ /* stick around for awhile */
reg->ref_count = 2; reg->ref_count = 2;
reg->base = (unsigned char *) base; reg->base = (unsigned char *) base;
reg->bound = (unsigned char *) bound; reg->bound = (unsigned char *) bound;
reg->flags = flags; reg->flags = flags;
xpmem_addr.apid = mca_btl_vader_component.apids[peer_smp_rank]; xpmem_addr.apid = mca_btl_vader_component.apids[peer_smp_rank];
xpmem_addr.offset = base; xpmem_addr.offset = base;
reg->alloc_base = xpmem_attach (xpmem_addr, bound - base, NULL); reg->alloc_base = xpmem_attach (xpmem_addr, bound - base, NULL);
if (OPAL_UNLIKELY((void *)-1 == reg->alloc_base)) { if (OPAL_UNLIKELY((void *)-1 == reg->alloc_base)) {
OBJ_RELEASE(reg); OBJ_RELEASE(reg);
reg = NULL; reg = NULL;
} else { } else {
rcache->rcache_insert (rcache, reg, 0); rcache->rcache_insert (rcache, reg, 0);
} }
} }
return reg; return reg;
@ -250,16 +250,16 @@ static inline void vader_return_registration (mca_mpool_base_registration_t *reg
opal_atomic_add (&reg->ref_count, -1); opal_atomic_add (&reg->ref_count, -1);
if (OPAL_UNLIKELY(0 == reg->ref_count && !(reg->flags & MCA_MPOOL_FLAGS_PERSIST))) { if (OPAL_UNLIKELY(0 == reg->ref_count && !(reg->flags & MCA_MPOOL_FLAGS_PERSIST))) {
rcache->rcache_delete (rcache, reg); rcache->rcache_delete (rcache, reg);
(void)xpmem_detach (reg->alloc_base); (void)xpmem_detach (reg->alloc_base);
OBJ_RELEASE (reg); OBJ_RELEASE (reg);
} }
} }
static inline void *vader_reg_to_ptr (mca_mpool_base_registration_t *reg, void *rem_ptr) static inline void *vader_reg_to_ptr (mca_mpool_base_registration_t *reg, void *rem_ptr)
{ {
return (void *) ((uintptr_t) reg->alloc_base + return (void *) ((uintptr_t) reg->alloc_base +
(ptrdiff_t)((uintptr_t) rem_ptr - (uintptr_t) reg->base)); (ptrdiff_t)((uintptr_t) rem_ptr - (uintptr_t) reg->base));
} }
/* memcpy is faster at larger sizes but is undefined if the /* memcpy is faster at larger sizes but is undefined if the
@ -267,9 +267,9 @@ static inline void *vader_reg_to_ptr (mca_mpool_base_registration_t *reg, void *
static inline void vader_memmove (void *dst, void *src, size_t size) static inline void vader_memmove (void *dst, void *src, size_t size)
{ {
if (size >= mca_btl_vader_memcpy_limit) { if (size >= mca_btl_vader_memcpy_limit) {
memcpy (dst, src, size); memcpy (dst, src, size);
} else { } else {
memmove (dst, src, size); memmove (dst, src, size);
} }
} }
@ -280,9 +280,9 @@ static inline void vader_memmove (void *dst, void *src, size_t size)
* @param peer (IN) BTL peer addressing * @param peer (IN) BTL peer addressing
*/ */
int mca_btl_vader_send(struct mca_btl_base_module_t *btl, int mca_btl_vader_send(struct mca_btl_base_module_t *btl,
struct mca_btl_base_endpoint_t *endpoint, struct mca_btl_base_endpoint_t *endpoint,
struct mca_btl_base_descriptor_t *descriptor, struct mca_btl_base_descriptor_t *descriptor,
mca_btl_base_tag_t tag); mca_btl_base_tag_t tag);
/** /**
* Initiate an inline send to the peer. * Initiate an inline send to the peer.
@ -291,12 +291,12 @@ int mca_btl_vader_send(struct mca_btl_base_module_t *btl,
* @param peer (IN) BTL peer addressing * @param peer (IN) BTL peer addressing
*/ */
int mca_btl_vader_sendi (struct mca_btl_base_module_t *btl, int mca_btl_vader_sendi (struct mca_btl_base_module_t *btl,
struct mca_btl_base_endpoint_t *endpoint, struct mca_btl_base_endpoint_t *endpoint,
struct opal_convertor_t *convertor, struct opal_convertor_t *convertor,
void *header, size_t header_size, void *header, size_t header_size,
size_t payload_size, uint8_t order, size_t payload_size, uint8_t order,
uint32_t flags, mca_btl_base_tag_t tag, uint32_t flags, mca_btl_base_tag_t tag,
mca_btl_base_descriptor_t **descriptor); mca_btl_base_descriptor_t **descriptor);
/** /**
* Initiate an synchronous put. * Initiate an synchronous put.
@ -306,8 +306,8 @@ int mca_btl_vader_sendi (struct mca_btl_base_module_t *btl,
* @param descriptor (IN) Description of the data to be transferred * @param descriptor (IN) Description of the data to be transferred
*/ */
int mca_btl_vader_put (struct mca_btl_base_module_t *btl, int mca_btl_vader_put (struct mca_btl_base_module_t *btl,
struct mca_btl_base_endpoint_t *endpoint, struct mca_btl_base_endpoint_t *endpoint,
struct mca_btl_base_descriptor_t *des); struct mca_btl_base_descriptor_t *des);
/** /**
* Initiate an synchronous get. * Initiate an synchronous get.
@ -317,8 +317,8 @@ int mca_btl_vader_put (struct mca_btl_base_module_t *btl,
* @param descriptor (IN) Description of the data to be transferred * @param descriptor (IN) Description of the data to be transferred
*/ */
int mca_btl_vader_get (struct mca_btl_base_module_t *btl, int mca_btl_vader_get (struct mca_btl_base_module_t *btl,
struct mca_btl_base_endpoint_t *endpoint, struct mca_btl_base_endpoint_t *endpoint,
struct mca_btl_base_descriptor_t *des); struct mca_btl_base_descriptor_t *des);
/** /**
* Allocate a segment. * Allocate a segment.
@ -327,8 +327,8 @@ int mca_btl_vader_get (struct mca_btl_base_module_t *btl,
* @param size (IN) Request segment size. * @param size (IN) Request segment size.
*/ */
mca_btl_base_descriptor_t* mca_btl_vader_alloc (struct mca_btl_base_module_t* btl, mca_btl_base_descriptor_t* mca_btl_vader_alloc (struct mca_btl_base_module_t* btl,
struct mca_btl_base_endpoint_t* endpoint, struct mca_btl_base_endpoint_t* endpoint,
uint8_t order, size_t size, uint32_t flags); uint8_t order, size_t size, uint32_t flags);
END_C_DECLS END_C_DECLS

84
ompi/mca/btl/vader/btl_vader_component.c
Просмотреть файл

@ -1,4 +1,4 @@
/* -*- Mode: C; c-basic-offset:4 ; -*- */ /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */
/* /*
* Copyright (c) 2004-2011 The Trustees of Indiana University and Indiana * Copyright (c) 2004-2011 The Trustees of Indiana University and Indiana
* University Research and Technology * University Research and Technology
@ -42,8 +42,8 @@ static int mca_btl_vader_component_open(void);
static int mca_btl_vader_component_close(void); static int mca_btl_vader_component_close(void);
static int mca_btl_vader_component_register(void); static int mca_btl_vader_component_register(void);
static mca_btl_base_module_t** mca_btl_vader_component_init(int *num_btls, static mca_btl_base_module_t** mca_btl_vader_component_init(int *num_btls,
bool enable_progress_threads, bool enable_progress_threads,
bool enable_mpi_threads); bool enable_mpi_threads);
/* limit where we should switch from bcopy to memcpy */ /* limit where we should switch from bcopy to memcpy */
int mca_btl_vader_memcpy_limit = 524288; int mca_btl_vader_memcpy_limit = 524288;
@ -57,7 +57,7 @@ int mca_btl_vader_max_inline_send = 256;
mca_btl_vader_component_t mca_btl_vader_component = { mca_btl_vader_component_t mca_btl_vader_component = {
{ {
/* First, the mca_base_component_t struct containing meta information /* First, the mca_base_component_t struct containing meta information
about the component itself */ about the component itself */
{ {
MCA_BTL_BASE_VERSION_2_0_0, MCA_BTL_BASE_VERSION_2_0_0,
@ -86,21 +86,21 @@ mca_btl_vader_component_t mca_btl_vader_component = {
*/ */
static inline char *mca_btl_vader_param_register_string(const char *param_name, static inline char *mca_btl_vader_param_register_string(const char *param_name,
const char *default_value) const char *default_value)
{ {
char *param_value; char *param_value;
int id = mca_base_param_register_string("btl", "vader", int id = mca_base_param_register_string("btl", "vader",
param_name, NULL, param_name, NULL,
default_value); default_value);
mca_base_param_lookup_string(id, &param_value); mca_base_param_lookup_string(id, &param_value);
return param_value; return param_value;
} }
static inline int mca_btl_vader_param_register_int(const char *param_name, static inline int mca_btl_vader_param_register_int(const char *param_name,
int value) int value)
{ {
int id = mca_base_param_register_int("btl", "vader", param_name, int id = mca_base_param_register_int("btl", "vader", param_name,
NULL, value); NULL, value);
mca_base_param_lookup_int(id, &value); mca_base_param_lookup_int(id, &value);
return value; return value;
} }
@ -127,11 +127,11 @@ static int mca_btl_vader_component_register (void)
mca_btl_vader_component.vader_mpool_name = mca_btl_vader_component.vader_mpool_name =
mca_btl_vader_param_register_string("mpool", "sm"); mca_btl_vader_param_register_string("mpool", "sm");
mca_btl_vader_memcpy_limit = mca_btl_vader_memcpy_limit =
mca_btl_vader_param_register_int("memcpy_limit", mca_btl_vader_memcpy_limit); mca_btl_vader_param_register_int("memcpy_limit", mca_btl_vader_memcpy_limit);
mca_btl_vader_segment_multiple = mca_btl_vader_segment_multiple =
msb(mca_btl_vader_param_register_int("segment_multiple", mca_btl_vader_segment_multiple)); msb(mca_btl_vader_param_register_int("segment_multiple", mca_btl_vader_segment_multiple));
mca_btl_vader_max_inline_send = mca_btl_vader_max_inline_send =
mca_btl_vader_param_register_int("max_inline_send", mca_btl_vader_max_inline_send); mca_btl_vader_param_register_int("max_inline_send", mca_btl_vader_max_inline_send);
mca_btl_vader.super.btl_exclusivity = MCA_BTL_EXCLUSIVITY_HIGH; mca_btl_vader.super.btl_exclusivity = MCA_BTL_EXCLUSIVITY_HIGH;
mca_btl_vader.super.btl_eager_limit = 64 * 1024; mca_btl_vader.super.btl_eager_limit = 64 * 1024;
@ -141,7 +141,7 @@ static int mca_btl_vader_component_register (void)
mca_btl_vader.super.btl_rdma_pipeline_frag_size = mca_btl_vader.super.btl_eager_limit; mca_btl_vader.super.btl_rdma_pipeline_frag_size = mca_btl_vader.super.btl_eager_limit;
mca_btl_vader.super.btl_min_rdma_pipeline_size = mca_btl_vader.super.btl_eager_limit; mca_btl_vader.super.btl_min_rdma_pipeline_size = mca_btl_vader.super.btl_eager_limit;
mca_btl_vader.super.btl_flags = MCA_BTL_FLAGS_GET | MCA_BTL_FLAGS_PUT | mca_btl_vader.super.btl_flags = MCA_BTL_FLAGS_GET | MCA_BTL_FLAGS_PUT |
MCA_BTL_FLAGS_SEND_INPLACE; MCA_BTL_FLAGS_SEND_INPLACE;
mca_btl_vader.super.btl_bandwidth = 40000; /* Mbs */ mca_btl_vader.super.btl_bandwidth = 40000; /* Mbs */
mca_btl_vader.super.btl_latency = 1; /* Microsecs */ mca_btl_vader.super.btl_latency = 1; /* Microsecs */
@ -199,7 +199,7 @@ static int mca_btl_vader_component_close(void)
* to it are gone - no error checking, since we want all procs * to it are gone - no error checking, since we want all procs
* to call this, so that in an abnormal termination scenario, * to call this, so that in an abnormal termination scenario,
* this file will still get cleaned up */ * this file will still get cleaned up */
/* XXX LANL TODO -- remove unlink once the shmem segment uses xpmem */ /* XXX LANL TODO -- remove unlink once the shmem segment uses xpmem */
unlink(mca_btl_vader_component.vader_seg->shmem_ds.seg_name); unlink(mca_btl_vader_component.vader_seg->shmem_ds.seg_name);
OBJ_RELEASE(mca_btl_vader_component.vader_seg); OBJ_RELEASE(mca_btl_vader_component.vader_seg);
} }
@ -220,8 +220,8 @@ static int mca_btl_vader_component_close(void)
* VADER component initialization * VADER component initialization
*/ */
static mca_btl_base_module_t **mca_btl_vader_component_init (int *num_btls, static mca_btl_base_module_t **mca_btl_vader_component_init (int *num_btls,
bool enable_progress_threads, bool enable_progress_threads,
bool enable_mpi_threads) bool enable_mpi_threads)
{ {
mca_btl_vader_component_t *component = &mca_btl_vader_component; mca_btl_vader_component_t *component = &mca_btl_vader_component;
mca_btl_base_module_t **btls = NULL; mca_btl_base_module_t **btls = NULL;
@ -266,24 +266,24 @@ static inline void mca_btl_vader_progress_sends (void)
mca_btl_vader_frag_t *frag; mca_btl_vader_frag_t *frag;
for (item = opal_list_get_first (list) ; item != opal_list_get_end (list) ; ) { for (item = opal_list_get_first (list) ; item != opal_list_get_end (list) ; ) {
frag = (mca_btl_vader_frag_t *) item; frag = (mca_btl_vader_frag_t *) item;
next = opal_list_get_next (item); next = opal_list_get_next (item);
if (OPAL_LIKELY(frag->hdr->complete)) { if (OPAL_LIKELY(frag->hdr->complete)) {
opal_list_remove_item (&mca_btl_vader_component.active_sends, item); opal_list_remove_item (&mca_btl_vader_component.active_sends, item);
if (OPAL_UNLIKELY(MCA_BTL_DES_SEND_ALWAYS_CALLBACK & frag->base.des_flags)) { if (OPAL_UNLIKELY(MCA_BTL_DES_SEND_ALWAYS_CALLBACK & frag->base.des_flags)) {
/* completion callback */ /* completion callback */
frag->base.des_cbfunc(&mca_btl_vader.super, frag->endpoint, frag->base.des_cbfunc(&mca_btl_vader.super, frag->endpoint,
&frag->base, OMPI_SUCCESS); &frag->base, OMPI_SUCCESS);
} }
if (OPAL_LIKELY(frag->base.des_flags & MCA_BTL_DES_FLAGS_BTL_OWNERSHIP)) { if (OPAL_LIKELY(frag->base.des_flags & MCA_BTL_DES_FLAGS_BTL_OWNERSHIP)) {
MCA_BTL_VADER_FRAG_RETURN(frag); MCA_BTL_VADER_FRAG_RETURN(frag);
} }
} }
item = next; item = next;
} }
} }
@ -308,7 +308,7 @@ static int mca_btl_vader_component_progress (void)
/* poll the fifo once */ /* poll the fifo once */
hdr = (mca_btl_vader_hdr_t *) vader_fifo_read (fifo); hdr = (mca_btl_vader_hdr_t *) vader_fifo_read (fifo);
if (VADER_FIFO_FREE == hdr) { if (VADER_FIFO_FREE == hdr) {
return 0; return 0;
} }
/* change the address from address relative to the shared /* change the address from address relative to the shared
@ -322,21 +322,21 @@ static int mca_btl_vader_component_progress (void)
segments[0].seg_len = hdr->len; segments[0].seg_len = hdr->len;
if (OPAL_UNLIKELY(hdr->flags & MCA_BTL_VADER_FLAG_SINGLE_COPY)) { if (OPAL_UNLIKELY(hdr->flags & MCA_BTL_VADER_FLAG_SINGLE_COPY)) {
struct iovec *rem_mem = (struct iovec *) ((uintptr_t)segments[0].seg_addr.pval + hdr->len); struct iovec *rem_mem = (struct iovec *) ((uintptr_t)segments[0].seg_addr.pval + hdr->len);
xpmem_reg = vader_get_registation (hdr->my_smp_rank, rem_mem->iov_base, xpmem_reg = vader_get_registation (hdr->my_smp_rank, rem_mem->iov_base,
rem_mem->iov_len, 0); rem_mem->iov_len, 0);
segments[1].seg_addr.pval = vader_reg_to_ptr (xpmem_reg, rem_mem->iov_base); segments[1].seg_addr.pval = vader_reg_to_ptr (xpmem_reg, rem_mem->iov_base);
segments[1].seg_len = rem_mem->iov_len; segments[1].seg_len = rem_mem->iov_len;
/* recv upcall */ /* recv upcall */
frag.base.des_dst_cnt = 2; frag.base.des_dst_cnt = 2;
reg->cbfunc(&mca_btl_vader.super, hdr->tag, &(frag.base), reg->cbdata); reg->cbfunc(&mca_btl_vader.super, hdr->tag, &(frag.base), reg->cbdata);
vader_return_registration (xpmem_reg, hdr->my_smp_rank); vader_return_registration (xpmem_reg, hdr->my_smp_rank);
} else { } else {
frag.base.des_dst_cnt = 1; frag.base.des_dst_cnt = 1;
reg->cbfunc(&mca_btl_vader.super, hdr->tag, &(frag.base), reg->cbdata); reg->cbfunc(&mca_btl_vader.super, hdr->tag, &(frag.base), reg->cbdata);
} }
/* return the fragment */ /* return the fragment */

2
ompi/mca/btl/vader/btl_vader_endpoint.h
Просмотреть файл

@ -1,4 +1,4 @@
/* -*- Mode: C; c-basic-offset:4 ; -*- */ /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */
/* /*
* Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana * Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
* University Research and Technology * University Research and Technology

62
ompi/mca/btl/vader/btl_vader_fbox.h
Просмотреть файл

@ -1,4 +1,4 @@
/* -*- Mode: C; c-basic-offset:4 ; -*- */ /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */
/* /*
* Copyright (c) 2011 Los Alamos National Security, LLC. * Copyright (c) 2011 Los Alamos National Security, LLC.
* All rights reserved. * All rights reserved.
@ -23,10 +23,10 @@
enum {MCA_BTL_VADER_FBOX_FREE = 0xfe, MCA_BTL_VADER_FBOX_RESERVED = 0xff}; enum {MCA_BTL_VADER_FBOX_FREE = 0xfe, MCA_BTL_VADER_FBOX_RESERVED = 0xff};
#define MCA_BTL_VADER_FBOX_OUT_PTR(peer_smp_rank, fbox) \ #define MCA_BTL_VADER_FBOX_OUT_PTR(peer_smp_rank, fbox) \
(mca_btl_vader_component.vader_fboxes_out[peer_smp_rank] + FBOX_SIZE * (fbox)) (mca_btl_vader_component.vader_fboxes_out[peer_smp_rank] + FBOX_SIZE * (fbox))
#define MCA_BTL_VADER_FBOX_IN_PTR(peer_smp_rank, fbox) \ #define MCA_BTL_VADER_FBOX_IN_PTR(peer_smp_rank, fbox) \
(mca_btl_vader_component.vader_fboxes_in[peer_smp_rank] + FBOX_SIZE * (fbox)) (mca_btl_vader_component.vader_fboxes_in[peer_smp_rank] + FBOX_SIZE * (fbox))
static inline unsigned char *mca_btl_vader_reserve_fbox (int peer_smp_rank, size_t size) static inline unsigned char *mca_btl_vader_reserve_fbox (int peer_smp_rank, size_t size)
@ -37,12 +37,12 @@ static inline unsigned char *mca_btl_vader_reserve_fbox (int peer_smp_rank, size
/* todo -- need thread locks here for the multi-threaded case */ /* todo -- need thread locks here for the multi-threaded case */
if (size > MAX_MSG || fbox[0] != MCA_BTL_VADER_FBOX_FREE) { if (size > MAX_MSG || fbox[0] != MCA_BTL_VADER_FBOX_FREE) {
/* fall back on fifo */ /* fall back on fifo */
return NULL; return NULL;
} }
mca_btl_vader_component.vader_next_fbox_out[peer_smp_rank] = mca_btl_vader_component.vader_next_fbox_out[peer_smp_rank] =
next_fbox == LAST_FBOX ? 0 : next_fbox + 1; next_fbox == LAST_FBOX ? 0 : next_fbox + 1;
/* mark this fast box as in use */ /* mark this fast box as in use */
fbox[0] = MCA_BTL_VADER_FBOX_RESERVED; fbox[0] = MCA_BTL_VADER_FBOX_RESERVED;
@ -61,20 +61,20 @@ static inline void mca_btl_vader_fbox_send (unsigned char *fbox, unsigned char t
} }
static inline int mca_btl_vader_fbox_sendi (struct mca_btl_base_endpoint_t *endpoint, char tag, static inline int mca_btl_vader_fbox_sendi (struct mca_btl_base_endpoint_t *endpoint, char tag,
void *header, size_t header_size, void *header, size_t header_size,
void *payload, size_t payload_size) void *payload, size_t payload_size)
{ {
unsigned char *fbox; unsigned char *fbox;
fbox = mca_btl_vader_reserve_fbox(endpoint->peer_smp_rank, header_size + payload_size); fbox = mca_btl_vader_reserve_fbox(endpoint->peer_smp_rank, header_size + payload_size);
if (NULL == fbox) { if (NULL == fbox) {
return 0; return 0;
} }
memcpy (fbox, header, header_size); memcpy (fbox, header, header_size);
if (OPAL_UNLIKELY(payload)) { if (OPAL_UNLIKELY(payload)) {
/* inline sends are typically just pml headers (due to MCA_BTL_FLAGS_SEND_INPLACE) */ /* inline sends are typically just pml headers (due to MCA_BTL_FLAGS_SEND_INPLACE) */
memcpy (fbox + header_size, payload, payload_size); memcpy (fbox + header_size, payload, payload_size);
} }
/* mark the fbox as sent */ /* mark the fbox as sent */
@ -93,35 +93,35 @@ static inline void mca_btl_vader_check_fboxes (void)
int i; int i;
for (i = 0 ; i < mca_btl_vader_component.num_smp_procs ; ++i) { for (i = 0 ; i < mca_btl_vader_component.num_smp_procs ; ++i) {
int next_fbox = mca_btl_vader_component.vader_next_fbox_in[i]; int next_fbox = mca_btl_vader_component.vader_next_fbox_in[i];
unsigned char *fbox = MCA_BTL_VADER_FBOX_IN_PTR(i, next_fbox); unsigned char *fbox = MCA_BTL_VADER_FBOX_IN_PTR(i, next_fbox);
if (my_smp_rank == i) { if (my_smp_rank == i) {
continue; continue;
} }
/* process all fast-box messages */ /* process all fast-box messages */
while (0xfe != ((size = fbox[0]) & 0xfe)) { while (0xfe != ((size = fbox[0]) & 0xfe)) {
opal_atomic_rmb (); opal_atomic_rmb ();
tag = fbox[1]; tag = fbox[1];
reg = mca_btl_base_active_message_trigger + tag; reg = mca_btl_base_active_message_trigger + tag;
frag.segment.seg_addr.pval = fbox + 2; frag.segment.seg_addr.pval = fbox + 2;
frag.segment.seg_len = size; frag.segment.seg_len = size;
frag.base.des_dst = &frag.segment; frag.base.des_dst = &frag.segment;
frag.base.des_dst_cnt = 1; frag.base.des_dst_cnt = 1;
reg->cbfunc(&mca_btl_vader.super, tag, &(frag.base), reg->cbdata); reg->cbfunc(&mca_btl_vader.super, tag, &(frag.base), reg->cbdata);
fbox[0] = MCA_BTL_VADER_FBOX_FREE; fbox[0] = MCA_BTL_VADER_FBOX_FREE;
next_fbox = next_fbox == LAST_FBOX ? 0 : next_fbox + 1; next_fbox = next_fbox == LAST_FBOX ? 0 : next_fbox + 1;
fbox = MCA_BTL_VADER_FBOX_IN_PTR(i, next_fbox); fbox = MCA_BTL_VADER_FBOX_IN_PTR(i, next_fbox);
} }
mca_btl_vader_component.vader_next_fbox_in[i] = next_fbox; mca_btl_vader_component.vader_next_fbox_in[i] = next_fbox;
} }
} }

54
ompi/mca/btl/vader/btl_vader_fifo.h
Просмотреть файл

@ -1,4 +1,4 @@
/* -*- Mode: C; c-basic-offset:4 ; -*- */ /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */
/* /*
* Copyright (c) 2004-2007 The Trustees of Indiana University and Indiana * Copyright (c) 2004-2007 The Trustees of Indiana University and Indiana
* University Research and Technology * University Research and Technology
@ -76,10 +76,10 @@ static inline void vader_fifo_write (void *value, vader_fifo_t *fifo)
opal_atomic_wmb (); opal_atomic_wmb ();
if (OPAL_LIKELY(VADER_FIFO_FREE != prev)) { if (OPAL_LIKELY(VADER_FIFO_FREE != prev)) {
hdr = (mca_btl_vader_hdr_t *) RELATIVE2VIRTUAL(prev); hdr = (mca_btl_vader_hdr_t *) RELATIVE2VIRTUAL(prev);
hdr->next = value; hdr->next = value;
} else { } else {
fifo->fifo_head = value; fifo->fifo_head = value;
} }
opal_atomic_wmb (); opal_atomic_wmb ();
@ -94,22 +94,22 @@ static inline void *vader_fifo_read (vader_fifo_t *fifo)
value = (void *) opal_atomic_swap_ptr (&fifo->fifo_head, (intptr_t) VADER_FIFO_FREE); value = (void *) opal_atomic_swap_ptr (&fifo->fifo_head, (intptr_t) VADER_FIFO_FREE);
if (VADER_FIFO_FREE == value) { if (VADER_FIFO_FREE == value) {
/* fifo is empty or we lost the race with another thread */ /* fifo is empty or we lost the race with another thread */
return value; return value;
} }
hdr = (mca_btl_vader_hdr_t *) RELATIVE2VIRTUAL(value); hdr = (mca_btl_vader_hdr_t *) RELATIVE2VIRTUAL(value);
if (OPAL_UNLIKELY(VADER_FIFO_FREE == hdr->next)) { if (OPAL_UNLIKELY(VADER_FIFO_FREE == hdr->next)) {
if (!opal_atomic_cmpset_ptr (&fifo->fifo_tail, value, VADER_FIFO_FREE)) { if (!opal_atomic_cmpset_ptr (&fifo->fifo_tail, value, VADER_FIFO_FREE)) {
while (VADER_FIFO_FREE == hdr->next) { while (VADER_FIFO_FREE == hdr->next) {
opal_atomic_rmb (); opal_atomic_rmb ();
} }
fifo->fifo_head = hdr->next; fifo->fifo_head = hdr->next;
} }
} else { } else {
fifo->fifo_head = hdr->next; fifo->fifo_head = hdr->next;
} }
opal_atomic_wmb (); opal_atomic_wmb ();
@ -154,10 +154,10 @@ static inline int vader_fifo_write (void *value, vader_fifo_t *fifo)
fifo->fifo_tail = value; fifo->fifo_tail = value;
if (OPAL_LIKELY(VADER_FIFO_FREE != prev)) { if (OPAL_LIKELY(VADER_FIFO_FREE != prev)) {
hdr = (mca_btl_vader_hdr_t *) RELATIVE2VIRTUAL(prev); hdr = (mca_btl_vader_hdr_t *) RELATIVE2VIRTUAL(prev);
hdr->next = value; hdr->next = value;
} else { } else {
fifo->fifo_head = value; fifo->fifo_head = value;
} }
opal_atomic_unlock(&(fifo->tail_lock)); opal_atomic_unlock(&(fifo->tail_lock));
@ -174,12 +174,12 @@ static inline void *vader_fifo_read (vader_fifo_t *fifo)
/* aquire thread lock */ /* aquire thread lock */
if (opal_using_threads ()) { if (opal_using_threads ()) {
opal_atomic_lock (&fifo->head_lock); opal_atomic_lock (&fifo->head_lock);
} }
opal_atomic_rmb(); opal_atomic_rmb();
if (VADER_FIFO_FREE == fifo->fifo_head) { if (VADER_FIFO_FREE == fifo->fifo_head) {
return VADER_FIFO_FREE; return VADER_FIFO_FREE;
} }
value = (void *) fifo->fifo_head; value = (void *) fifo->fifo_head;
@ -187,20 +187,20 @@ static inline void *vader_fifo_read (vader_fifo_t *fifo)
fifo->fifo_head = hdr->next; fifo->fifo_head = hdr->next;
if (OPAL_UNLIKELY(VADER_FIFO_FREE == fifo->fifo_head)) { if (OPAL_UNLIKELY(VADER_FIFO_FREE == fifo->fifo_head)) {
opal_atomic_rmb(); opal_atomic_rmb();
opal_atomic_lock(&(fifo->tail_lock)); opal_atomic_lock(&(fifo->tail_lock));
if (OPAL_LIKELY(fifo->fifo_tail == value)) { if (OPAL_LIKELY(fifo->fifo_tail == value)) {
fifo->fifo_tail = VADER_FIFO_FREE; fifo->fifo_tail = VADER_FIFO_FREE;
} else { } else {
fifo->fifo_head = hdr->next; fifo->fifo_head = hdr->next;
} }
opal_atomic_unlock(&(fifo->tail_lock)); opal_atomic_unlock(&(fifo->tail_lock));
} }
/* release thread lock */ /* release thread lock */
if (opal_using_threads ()) { if (opal_using_threads ()) {
opal_atomic_unlock (&fifo->head_lock); opal_atomic_unlock (&fifo->head_lock);
} }
return value; return value;

4
ompi/mca/btl/vader/btl_vader_frag.c
Просмотреть файл

@ -1,4 +1,4 @@
/* -*- Mode: C; c-basic-offset:4 ; -*- */ /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */
/* /*
* Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana * Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
* University Research and Technology * University Research and Technology
@ -34,4 +34,4 @@ static inline void mca_btl_vader_frag_constructor (mca_btl_vader_frag_t *frag)
} }
OBJ_CLASS_INSTANCE(mca_btl_vader_frag_t, mca_btl_base_descriptor_t, OBJ_CLASS_INSTANCE(mca_btl_vader_frag_t, mca_btl_base_descriptor_t,
mca_btl_vader_frag_constructor, NULL); mca_btl_vader_frag_constructor, NULL);

42
ompi/mca/btl/vader/btl_vader_frag.h
Просмотреть файл

@ -1,4 +1,4 @@
/* -*- Mode: C; c-basic-offset:4 ; -*- */ /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */
/* /*
* Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana * Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
* University Research and Technology * University Research and Technology
@ -57,30 +57,30 @@ typedef struct mca_btl_vader_frag_t mca_btl_vader_frag_t;
OBJ_CLASS_DECLARATION(mca_btl_vader_frag_t); OBJ_CLASS_DECLARATION(mca_btl_vader_frag_t);
#define MCA_BTL_VADER_FRAG_ALLOC_EAGER(frag, rc) \ #define MCA_BTL_VADER_FRAG_ALLOC_EAGER(frag, rc) \
do { \ do { \
ompi_free_list_item_t *item; \ ompi_free_list_item_t *item; \
OMPI_FREE_LIST_GET(&mca_btl_vader_component.vader_frags_eager, item, rc); \ OMPI_FREE_LIST_GET(&mca_btl_vader_component.vader_frags_eager, item, rc); \
frag = (mca_btl_vader_frag_t *) item; \ frag = (mca_btl_vader_frag_t *) item; \
frag->hdr->complete = false; \ frag->hdr->complete = false; \
frag->hdr->flags = MCA_BTL_VADER_FLAG_INLINE; \ frag->hdr->flags = MCA_BTL_VADER_FLAG_INLINE; \
frag->segment.seg_addr.pval = (char *)(frag->hdr + 1); \ frag->segment.seg_addr.pval = (char *)(frag->hdr + 1); \
frag->my_list = &mca_btl_vader_component.vader_frags_eager; \ frag->my_list = &mca_btl_vader_component.vader_frags_eager; \
} while (0) } while (0)
#define MCA_BTL_VADER_FRAG_ALLOC_USER(frag, rc) \ #define MCA_BTL_VADER_FRAG_ALLOC_USER(frag, rc) \
do { \ do { \
ompi_free_list_item_t *item; \ ompi_free_list_item_t *item; \
OMPI_FREE_LIST_GET(&mca_btl_vader_component.vader_frags_user, item, rc); \ OMPI_FREE_LIST_GET(&mca_btl_vader_component.vader_frags_user, item, rc); \
frag = (mca_btl_vader_frag_t *) item; \ frag = (mca_btl_vader_frag_t *) item; \
frag->hdr->complete = false; \ frag->hdr->complete = false; \
frag->hdr->flags = MCA_BTL_VADER_FLAG_INLINE; \ frag->hdr->flags = MCA_BTL_VADER_FLAG_INLINE; \
frag->segment.seg_addr.pval = (char *)(frag->hdr + 1); \ frag->segment.seg_addr.pval = (char *)(frag->hdr + 1); \
frag->my_list = &mca_btl_vader_component.vader_frags_user; \ frag->my_list = &mca_btl_vader_component.vader_frags_user; \
} while (0) } while (0)
#define MCA_BTL_VADER_FRAG_RETURN(frag) \ #define MCA_BTL_VADER_FRAG_RETURN(frag) \
OMPI_FREE_LIST_RETURN((frag)->my_list, (ompi_free_list_item_t *)(frag)) OMPI_FREE_LIST_RETURN((frag)->my_list, (ompi_free_list_item_t *)(frag))
#endif /* MCA_BTL_VADER_SEND_FRAG_H */ #endif /* MCA_BTL_VADER_SEND_FRAG_H */

12
ompi/mca/btl/vader/btl_vader_get.c
Просмотреть файл

@ -1,4 +1,4 @@
/* -*- Mode: C; c-basic-offset:4 ; -*- */ /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */
/* /*
* Copyright (c) 2010-2011 Los Alamos National Security, LLC. * Copyright (c) 2010-2011 Los Alamos National Security, LLC.
* All rights reserved. * All rights reserved.
@ -23,8 +23,8 @@
* @param descriptor (IN) Description of the data to be transferred * @param descriptor (IN) Description of the data to be transferred
*/ */
int mca_btl_vader_get (struct mca_btl_base_module_t *btl, int mca_btl_vader_get (struct mca_btl_base_module_t *btl,
struct mca_btl_base_endpoint_t *endpoint, struct mca_btl_base_endpoint_t *endpoint,
struct mca_btl_base_descriptor_t *des) struct mca_btl_base_descriptor_t *des)
{ {
mca_btl_vader_frag_t *frag = (mca_btl_vader_frag_t *) des; mca_btl_vader_frag_t *frag = (mca_btl_vader_frag_t *) des;
mca_btl_base_segment_t *src = des->des_src; mca_btl_base_segment_t *src = des->des_src;
@ -34,10 +34,10 @@ int mca_btl_vader_get (struct mca_btl_base_module_t *btl,
void *rem_ptr; void *rem_ptr;
reg = vader_get_registation (endpoint->peer_smp_rank, reg = vader_get_registation (endpoint->peer_smp_rank,
(void *) src->seg_key.ptr, (void *) src->seg_key.ptr,
src->seg_len, 0); src->seg_len, 0);
if (OPAL_UNLIKELY(NULL == reg)) { if (OPAL_UNLIKELY(NULL == reg)) {
return OMPI_ERROR; return OMPI_ERROR;
} }
rem_ptr = vader_reg_to_ptr (reg, (void *) src->seg_key.ptr); rem_ptr = vader_reg_to_ptr (reg, (void *) src->seg_key.ptr);

14
ompi/mca/btl/vader/btl_vader_put.c
Просмотреть файл

@ -1,4 +1,4 @@
/* -*- Mode: C; c-basic-offset:4 ; -*- */ /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */
/* /*
* Copyright (c) 2010-2011 Los Alamos National Security, LLC. * Copyright (c) 2010-2011 Los Alamos National Security, LLC.
* All rights reserved. * All rights reserved.
@ -23,8 +23,8 @@
* @param descriptor (IN) Description of the data to be transferred * @param descriptor (IN) Description of the data to be transferred
*/ */
int mca_btl_vader_put (struct mca_btl_base_module_t *btl, int mca_btl_vader_put (struct mca_btl_base_module_t *btl,
struct mca_btl_base_endpoint_t *endpoint, struct mca_btl_base_endpoint_t *endpoint,
struct mca_btl_base_descriptor_t *des) struct mca_btl_base_descriptor_t *des)
{ {
mca_btl_vader_frag_t *frag = (mca_btl_vader_frag_t *) des; mca_btl_vader_frag_t *frag = (mca_btl_vader_frag_t *) des;
mca_btl_base_segment_t *src = des->des_src; mca_btl_base_segment_t *src = des->des_src;
@ -34,10 +34,10 @@ int mca_btl_vader_put (struct mca_btl_base_module_t *btl,
void *rem_ptr; void *rem_ptr;
reg = vader_get_registation (endpoint->peer_smp_rank, reg = vader_get_registation (endpoint->peer_smp_rank,
(void *) dst->seg_key.ptr, (void *) dst->seg_key.ptr,
dst->seg_len, 0); dst->seg_len, 0);
if (OPAL_UNLIKELY(NULL == reg)) { if (OPAL_UNLIKELY(NULL == reg)) {
return OMPI_ERROR; return OMPI_ERROR;
} }
rem_ptr = vader_reg_to_ptr (reg, (void *) dst->seg_key.ptr); rem_ptr = vader_reg_to_ptr (reg, (void *) dst->seg_key.ptr);
@ -49,7 +49,7 @@ int mca_btl_vader_put (struct mca_btl_base_module_t *btl,
/* always call the callback function (if it exists) */ /* always call the callback function (if it exists) */
if (OPAL_LIKELY(NULL != frag->base.des_cbfunc)) { if (OPAL_LIKELY(NULL != frag->base.des_cbfunc)) {
frag->base.des_cbfunc(&mca_btl_vader.super, frag->endpoint, frag->base.des_cbfunc(&mca_btl_vader.super, frag->endpoint,
&frag->base, OMPI_SUCCESS); &frag->base, OMPI_SUCCESS);
} }
if (frag->base.des_flags & MCA_BTL_DES_FLAGS_BTL_OWNERSHIP) { if (frag->base.des_flags & MCA_BTL_DES_FLAGS_BTL_OWNERSHIP) {

24
ompi/mca/btl/vader/btl_vader_send.c
Просмотреть файл

@ -1,4 +1,4 @@
/* -*- Mode: C; c-basic-offset:4 ; -*- */ /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */
/* /*
* Copyright (c) 2004-2011 The Trustees of Indiana University and Indiana * Copyright (c) 2004-2011 The Trustees of Indiana University and Indiana
* University Research and Technology * University Research and Technology
@ -35,20 +35,20 @@
* @param peer (IN) BTL peer addressing * @param peer (IN) BTL peer addressing
*/ */
int mca_btl_vader_send (struct mca_btl_base_module_t *btl, int mca_btl_vader_send (struct mca_btl_base_module_t *btl,
struct mca_btl_base_endpoint_t *endpoint, struct mca_btl_base_endpoint_t *endpoint,
struct mca_btl_base_descriptor_t *descriptor, struct mca_btl_base_descriptor_t *descriptor,
mca_btl_base_tag_t tag) mca_btl_base_tag_t tag)
{ {
mca_btl_vader_frag_t *frag = (mca_btl_vader_frag_t *) descriptor; mca_btl_vader_frag_t *frag = (mca_btl_vader_frag_t *) descriptor;
if (frag->hdr->flags & MCA_BTL_VADER_FLAG_FBOX) { if (frag->hdr->flags & MCA_BTL_VADER_FLAG_FBOX) {
mca_btl_vader_fbox_send (frag->segment.seg_addr.pval, tag, frag->segment.seg_len); mca_btl_vader_fbox_send (frag->segment.seg_addr.pval, tag, frag->segment.seg_len);
if (OPAL_LIKELY(frag->base.des_flags & MCA_BTL_DES_FLAGS_BTL_OWNERSHIP)) { if (OPAL_LIKELY(frag->base.des_flags & MCA_BTL_DES_FLAGS_BTL_OWNERSHIP)) {
MCA_BTL_VADER_FRAG_RETURN(frag); MCA_BTL_VADER_FRAG_RETURN(frag);
} }
return 1; return 1;
} }
/* available header space */ /* available header space */
@ -60,11 +60,11 @@ int mca_btl_vader_send (struct mca_btl_base_module_t *btl,
/* post the relative address of the descriptor into the peer's fifo */ /* post the relative address of the descriptor into the peer's fifo */
vader_fifo_write ((void *) VIRTUAL2RELATIVE(frag->hdr), vader_fifo_write ((void *) VIRTUAL2RELATIVE(frag->hdr),
mca_btl_vader_component.fifo[endpoint->peer_smp_rank]); mca_btl_vader_component.fifo[endpoint->peer_smp_rank]);
if (frag->hdr->flags & MCA_BTL_VADER_FLAG_SINGLE_COPY) { if (frag->hdr->flags & MCA_BTL_VADER_FLAG_SINGLE_COPY) {
frag->base.des_flags |= MCA_BTL_DES_SEND_ALWAYS_CALLBACK; frag->base.des_flags |= MCA_BTL_DES_SEND_ALWAYS_CALLBACK;
return 0; return 0;
} }
/* data is gone */ /* data is gone */

48
ompi/mca/btl/vader/btl_vader_sendi.c
Просмотреть файл

@ -1,4 +1,4 @@
/* -*- Mode: C; c-basic-offset:4 ; -*- */ /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */
/* /*
* Copyright (c) 2004-2011 The Trustees of Indiana University and Indiana * Copyright (c) 2004-2011 The Trustees of Indiana University and Indiana
* University Research and Technology * University Research and Technology
@ -36,12 +36,12 @@
* @param peer (IN) BTL peer addressing * @param peer (IN) BTL peer addressing
*/ */
int mca_btl_vader_sendi (struct mca_btl_base_module_t *btl, int mca_btl_vader_sendi (struct mca_btl_base_module_t *btl,
struct mca_btl_base_endpoint_t *endpoint, struct mca_btl_base_endpoint_t *endpoint,
struct opal_convertor_t *convertor, struct opal_convertor_t *convertor,
void *header, size_t header_size, void *header, size_t header_size,
size_t payload_size, uint8_t order, size_t payload_size, uint8_t order,
uint32_t flags, mca_btl_base_tag_t tag, uint32_t flags, mca_btl_base_tag_t tag,
mca_btl_base_descriptor_t **descriptor) mca_btl_base_descriptor_t **descriptor)
{ {
size_t length = (header_size + payload_size); size_t length = (header_size + payload_size);
mca_btl_vader_frag_t *frag; mca_btl_vader_frag_t *frag;
@ -57,20 +57,20 @@ int mca_btl_vader_sendi (struct mca_btl_base_module_t *btl,
*descriptor = NULL; *descriptor = NULL;
if (OPAL_LIKELY(!(payload_size && opal_convertor_need_buffers (convertor)))) { if (OPAL_LIKELY(!(payload_size && opal_convertor_need_buffers (convertor)))) {
if (payload_size) { if (payload_size) {
opal_convertor_get_current_pointer (convertor, &data_ptr); opal_convertor_get_current_pointer (convertor, &data_ptr);
} }
if (mca_btl_vader_fbox_sendi (endpoint, tag, header, header_size, data_ptr, payload_size)) { if (mca_btl_vader_fbox_sendi (endpoint, tag, header, header_size, data_ptr, payload_size)) {
return OMPI_SUCCESS; return OMPI_SUCCESS;
} }
} }
/* allocate a fragment, giving up if we can't get one */ /* allocate a fragment, giving up if we can't get one */
frag = (mca_btl_vader_frag_t *) mca_btl_vader_alloc (btl, endpoint, order, length, frag = (mca_btl_vader_frag_t *) mca_btl_vader_alloc (btl, endpoint, order, length,
flags | MCA_BTL_DES_FLAGS_BTL_OWNERSHIP); flags | MCA_BTL_DES_FLAGS_BTL_OWNERSHIP);
if (OPAL_UNLIKELY(NULL == frag)) { if (OPAL_UNLIKELY(NULL == frag)) {
return OMPI_ERR_OUT_OF_RESOURCE; return OMPI_ERR_OUT_OF_RESOURCE;
} }
/* fill in fragment fields */ /* fill in fragment fields */
@ -87,24 +87,24 @@ int mca_btl_vader_sendi (struct mca_btl_base_module_t *btl,
/* we can't use single-copy semantics here since as caller will consider the send /* we can't use single-copy semantics here since as caller will consider the send
complete if we return success */ complete if we return success */
if (OPAL_UNLIKELY(payload_size && opal_convertor_need_buffers (convertor))) { if (OPAL_UNLIKELY(payload_size && opal_convertor_need_buffers (convertor))) {
/* pack the data into the supplied buffer */ /* pack the data into the supplied buffer */
iov.iov_base = (IOVBASE_TYPE *)((uintptr_t)frag->segment.seg_addr.pval + header_size); iov.iov_base = (IOVBASE_TYPE *)((uintptr_t)frag->segment.seg_addr.pval + header_size);
iov.iov_len = max_data = payload_size; iov.iov_len = max_data = payload_size;
(void) opal_convertor_pack (convertor, &iov, &iov_count, &max_data); (void) opal_convertor_pack (convertor, &iov, &iov_count, &max_data);
assert (max_data == payload_size); assert (max_data == payload_size);
} else if (payload_size) { } else if (payload_size) {
/* bypassing the convertor may speed things up a little */ /* bypassing the convertor may speed things up a little */
opal_convertor_get_current_pointer (convertor, &data_ptr); opal_convertor_get_current_pointer (convertor, &data_ptr);
memcpy ((void *)((uintptr_t)frag->segment.seg_addr.pval + header_size), data_ptr, payload_size); memcpy ((void *)((uintptr_t)frag->segment.seg_addr.pval + header_size), data_ptr, payload_size);
} }
opal_list_append (&mca_btl_vader_component.active_sends, (opal_list_item_t *) frag); opal_list_append (&mca_btl_vader_component.active_sends, (opal_list_item_t *) frag);
/* write the fragment pointer to peer's the FIFO */ /* write the fragment pointer to peer's the FIFO */
vader_fifo_write ((void *) VIRTUAL2RELATIVE(frag->hdr), vader_fifo_write ((void *) VIRTUAL2RELATIVE(frag->hdr),
mca_btl_vader_component.fifo[endpoint->peer_smp_rank]); mca_btl_vader_component.fifo[endpoint->peer_smp_rank]);
/* the progress function will return the fragment */ /* the progress function will return the fragment */