Adding more fixes to stomp casting/addressing issues on 32-bit systems.
This commit was SVN r29164.
Этот коммит содержится в:
Joshua Ladd
родитель
096b8c022e
Коммит
027e7deb7f
@ -38,7 +38,7 @@ OSHMEM_DECLSPEC extern struct mca_memheap_base_module_t* mca_memheap_base_module
|
||||
#define MEMHEAP_BASE_PRIVATE_SIZE (1ULL << MEMHEAP_BASE_PAGE_ORDER) /* should be at least the same as a huge page size */
|
||||
#define MEMHEAP_BASE_MIN_SIZE (1ULL << MEMHEAP_BASE_PAGE_ORDER) /* must fit into at least one huge page */
|
||||
|
||||
extern unsigned long long mca_memheap_base_start_address;
|
||||
extern void* mca_memheap_base_start_address;
|
||||
extern char* mca_memheap_base_include;
|
||||
extern char* mca_memheap_base_exclude;
|
||||
extern int mca_memheap_base_already_opened;
|
||||
@ -84,8 +84,8 @@ typedef struct map_segment_t {
|
||||
int is_active; /* enable/disable flag */
|
||||
int shmid;
|
||||
|
||||
uint64_t start; /* base address of the segment */
|
||||
uint64_t end; /* final address of the segment */
|
||||
void* start; /* base address of the segment */
|
||||
void* end; /* final address of the segment */
|
||||
size_t size; /* length of the segment */
|
||||
|
||||
segment_type_t type; /* type of the segment */
|
||||
@ -111,15 +111,15 @@ void memheap_oob_destruct(void);
|
||||
|
||||
OSHMEM_DECLSPEC uint64_t mca_memheap_base_find_offset(int pe,
|
||||
int tr_id,
|
||||
unsigned long va,
|
||||
uint64_t rva);
|
||||
OSHMEM_DECLSPEC int mca_memheap_base_is_symmetric_addr(unsigned long va);
|
||||
OSHMEM_DECLSPEC mca_spml_mkey_t *mca_memheap_base_get_mkey(unsigned long va,
|
||||
void* va,
|
||||
void* rva);
|
||||
OSHMEM_DECLSPEC int mca_memheap_base_is_symmetric_addr(const void* va);
|
||||
OSHMEM_DECLSPEC mca_spml_mkey_t *mca_memheap_base_get_mkey(void* va,
|
||||
int tr_id);
|
||||
OSHMEM_DECLSPEC mca_spml_mkey_t * mca_memheap_base_get_cached_mkey(int pe,
|
||||
unsigned long va,
|
||||
void* va,
|
||||
int btl_id,
|
||||
uint64_t *rva);
|
||||
void** rva);
|
||||
OSHMEM_DECLSPEC void mca_memheap_modex_recv_all(void);
|
||||
|
||||
/* This function is for internal usage only
|
||||
@ -133,7 +133,7 @@ typedef enum {
|
||||
ADDR_INVALID = 0, ADDR_USER, ADDR_PRIVATE, ADDR_STATIC,
|
||||
} addr_type_t;
|
||||
|
||||
OSHMEM_DECLSPEC int mca_memheap_base_detect_addr_type(unsigned long va);
|
||||
OSHMEM_DECLSPEC int mca_memheap_base_detect_addr_type(void* va);
|
||||
|
||||
static inline unsigned memheap_log2(unsigned long long val)
|
||||
{
|
||||
|
||||
@ -243,7 +243,7 @@ static int __shm_attach(map_segment_t *s, size_t size, int use_hp, int do_rmid)
|
||||
|
||||
s->type = MAP_SEGMENT_ALLOC_SHM;
|
||||
s->shmid = shmid;
|
||||
s->start = (uintptr_t) addr;
|
||||
s->start = addr;
|
||||
s->size = size;
|
||||
s->end = s->start + s->size;
|
||||
s->context = &shm_context;
|
||||
@ -295,7 +295,7 @@ MAP_ANONYMOUS
|
||||
|
||||
s->type = MAP_SEGMENT_ALLOC_MMAP;
|
||||
s->shmid = MEMHEAP_SHM_INVALID;
|
||||
s->start = (uintptr_t) addr;
|
||||
s->start = addr;
|
||||
s->size = size;
|
||||
s->end = s->start + s->size;
|
||||
s->context = NULL;
|
||||
@ -472,7 +472,7 @@ static int __ibv_attach(map_segment_t *s, size_t size)
|
||||
|
||||
s->type = MAP_SEGMENT_ALLOC_IBV;
|
||||
s->shmid = device->ib_mr_shared->handle;
|
||||
s->start = (intptr_t)ib_mr->addr;
|
||||
s->start = ib_mr->addr;
|
||||
s->size = size;
|
||||
s->end = s->start + s->size;
|
||||
s->context = &memheap_device;
|
||||
|
||||
@ -33,7 +33,7 @@ int mca_memheap_base_alloc_type = 5;
|
||||
int mca_memheap_base_alloc_type = 1;
|
||||
#endif /* MPAGE_ENABLE */
|
||||
|
||||
unsigned long long int mca_memheap_base_start_address = 0xFF000000;
|
||||
void* mca_memheap_base_start_address = (void*)0xFF000000;
|
||||
int mca_memheap_base_output = -1;
|
||||
int mca_memheap_base_key_exchange = 1;
|
||||
int mca_memheap_base_mr_interleave_factor = 2;
|
||||
|
||||
@ -66,33 +66,33 @@ static int memheap_oob_get_mkeys(int pe,
|
||||
uint32_t va_seg_num,
|
||||
mca_spml_mkey_t *mkey);
|
||||
|
||||
static inline unsigned long __seg2base_va(int seg)
|
||||
static inline void* __seg2base_va(int seg)
|
||||
{
|
||||
return memheap_map->mem_segs[seg].start;
|
||||
}
|
||||
|
||||
static int __seg_cmp(const void *k, const void *v)
|
||||
{
|
||||
unsigned long va = (unsigned long) k;
|
||||
uintptr_t va = (uintptr_t) k;
|
||||
map_segment_t *s = (map_segment_t *) v;
|
||||
|
||||
if (va < s->start)
|
||||
if (va < (uintptr_t)s->start)
|
||||
return -1;
|
||||
if (va >= s->end)
|
||||
if (va >= (uintptr_t)s->end)
|
||||
return 1;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline map_segment_t *__find_va(unsigned long va)
|
||||
static inline map_segment_t *__find_va(const void* va)
|
||||
{
|
||||
map_segment_t *s;
|
||||
|
||||
if (OPAL_LIKELY(va >= (unsigned long)memheap_map->mem_segs[HEAP_SEG_INDEX].start &&
|
||||
va < (unsigned long)memheap_map->mem_segs[HEAP_SEG_INDEX].end)) {
|
||||
if (OPAL_LIKELY((uintptr_t)va >= (uintptr_t)memheap_map->mem_segs[HEAP_SEG_INDEX].start &&
|
||||
(uintptr_t)va < (uintptr_t)memheap_map->mem_segs[HEAP_SEG_INDEX].end)) {
|
||||
s = &memheap_map->mem_segs[HEAP_SEG_INDEX];
|
||||
} else {
|
||||
s = bsearch((const void *) va,
|
||||
s = bsearch(va,
|
||||
&memheap_map->mem_segs[SYMB_SEG_INDEX],
|
||||
memheap_map->n_segments - 1,
|
||||
sizeof(*s),
|
||||
@ -155,8 +155,8 @@ static int do_mkey_req(opal_buffer_t *msg, int pe, int seg)
|
||||
}
|
||||
|
||||
MEMHEAP_VERBOSE(5,
|
||||
"seg#%d tr_id: %d key %llx base_va %llx",
|
||||
seg, tr_id, (unsigned long long)mkey->key, (unsigned long long)mkey->va_base);
|
||||
"seg#%d tr_id: %d key %llx base_va %p",
|
||||
seg, tr_id, (unsigned long long)mkey->key, mkey->va_base);
|
||||
}
|
||||
return OSHMEM_SUCCESS;
|
||||
}
|
||||
@ -171,15 +171,15 @@ static void memheap_attach_segment(mca_spml_mkey_t *mkey, int tr_id)
|
||||
if (!mkey->va_base
|
||||
&& ((int) MEMHEAP_SHM_GET_ID(mkey->key) != MEMHEAP_SHM_INVALID)) {
|
||||
MEMHEAP_VERBOSE(5,
|
||||
"shared memory usage tr_id: %d key %llx base_va %llx shmid 0x%X|0x%X",
|
||||
tr_id,
|
||||
(unsigned long long)mkey->key,
|
||||
(unsigned long long)mkey->va_base,
|
||||
"shared memory usage tr_id: %d key %llx base_va %p shmid 0x%X|0x%X",
|
||||
tr_id,
|
||||
(unsigned long long)mkey->key,
|
||||
mkey->va_base,
|
||||
MEMHEAP_SHM_GET_TYPE(mkey->key),
|
||||
MEMHEAP_SHM_GET_ID(mkey->key));
|
||||
|
||||
if (MEMHEAP_SHM_GET_TYPE(mkey->key) == MAP_SEGMENT_ALLOC_SHM) {
|
||||
mkey->va_base = (intptr_t) shmat(MEMHEAP_SHM_GET_ID(mkey->key),
|
||||
mkey->va_base = shmat(MEMHEAP_SHM_GET_ID(mkey->key),
|
||||
0,
|
||||
0);
|
||||
} else if (MEMHEAP_SHM_GET_TYPE(mkey->key) == MAP_SEGMENT_ALLOC_IBV) {
|
||||
@ -204,7 +204,7 @@ static void memheap_attach_segment(mca_spml_mkey_t *mkey, int tr_id)
|
||||
device->ib_pd, addr, access_flag);
|
||||
if (NULL == ib_mr)
|
||||
{
|
||||
mkey->va_base = -1;
|
||||
mkey->va_base = (void*)-1;
|
||||
MEMHEAP_ERROR("error to ibv_reg_shared_mr() errno says %d: %s",
|
||||
errno, strerror(errno));
|
||||
}
|
||||
@ -215,7 +215,7 @@ static void memheap_attach_segment(mca_spml_mkey_t *mkey, int tr_id)
|
||||
}
|
||||
|
||||
opal_value_array_append_item(&device->ib_mr_array, &ib_mr);
|
||||
mkey->va_base = (intptr_t)ib_mr->addr;
|
||||
mkey->va_base = ib_mr->addr;
|
||||
}
|
||||
#endif /* MPAGE_ENABLE */
|
||||
} else {
|
||||
@ -267,8 +267,8 @@ static void do_mkey_resp(opal_buffer_t *msg)
|
||||
memheap_attach_segment(&memheap_oob.mkeys[tr_id], tr_id);
|
||||
|
||||
MEMHEAP_VERBOSE(5,
|
||||
"tr_id: %d key %llx base_va %llx",
|
||||
tr_id, (unsigned long long)memheap_oob.mkeys[tr_id].key, (unsigned long long)memheap_oob.mkeys[tr_id].va_base);
|
||||
"tr_id: %d key %llx base_va %p",
|
||||
tr_id, (unsigned long long)memheap_oob.mkeys[tr_id].key, memheap_oob.mkeys[tr_id].va_base);
|
||||
}
|
||||
}
|
||||
|
||||
@ -401,11 +401,11 @@ static int memheap_oob_get_mkeys(int pe, uint32_t seg, mca_spml_mkey_t *mkeys)
|
||||
for (i = 0; i < memheap_map->num_transports; i++) {
|
||||
mkeys[i].va_base = __seg2base_va(seg);
|
||||
MEMHEAP_VERBOSE(5,
|
||||
"MKEY CALCULATED BY LOCAL SPML: pe: %d tr_id: %d key %llx base_va %llx",
|
||||
"MKEY CALCULATED BY LOCAL SPML: pe: %d tr_id: %d key %llx base_va %p",
|
||||
pe,
|
||||
i,
|
||||
(unsigned long long)mkeys[i].key,
|
||||
(unsigned long long)mkeys[i].va_base);
|
||||
i,
|
||||
(unsigned long long)mkeys[i].key,
|
||||
mkeys[i].va_base);
|
||||
}
|
||||
return OSHMEM_SUCCESS;
|
||||
}
|
||||
@ -461,7 +461,7 @@ void mca_memheap_modex_recv_all(void)
|
||||
int nprocs, my_pe;
|
||||
oshmem_proc_t *proc;
|
||||
mca_spml_mkey_t *mkey;
|
||||
uint64_t dummy_rva;
|
||||
void* dummy_rva;
|
||||
|
||||
if (!mca_memheap_base_key_exchange)
|
||||
return;
|
||||
@ -524,24 +524,24 @@ void mca_memheap_modex_recv_all(void)
|
||||
}
|
||||
}
|
||||
|
||||
static inline uint64_t va2rva(unsigned long va,
|
||||
uint64_t local_base,
|
||||
uint64_t remote_base)
|
||||
static inline void* va2rva(void* va,
|
||||
void* local_base,
|
||||
void* remote_base)
|
||||
{
|
||||
return remote_base > local_base ? va + (remote_base - local_base) :
|
||||
va - (local_base - remote_base);
|
||||
return (void*) (remote_base > local_base ? (uintptr_t)va + (remote_base - local_base) :
|
||||
(uintptr_t)va - (local_base - remote_base));
|
||||
}
|
||||
|
||||
mca_spml_mkey_t * mca_memheap_base_get_cached_mkey(int pe,
|
||||
unsigned long va,
|
||||
void* va,
|
||||
int btl_id,
|
||||
uint64_t *rva)
|
||||
void** rva)
|
||||
{
|
||||
map_segment_t *s;
|
||||
int rc;
|
||||
mca_spml_mkey_t *mkey;
|
||||
|
||||
MEMHEAP_VERBOSE_FASTPATH(10, "rkey: pe=%d va=%p", pe, (void *)va);
|
||||
MEMHEAP_VERBOSE_FASTPATH(10, "rkey: pe=%d va=%p", pe, va);
|
||||
s = __find_va(va);
|
||||
if (NULL == s)
|
||||
return NULL ;
|
||||
@ -551,8 +551,8 @@ mca_spml_mkey_t * mca_memheap_base_get_cached_mkey(int pe,
|
||||
|
||||
if (pe == oshmem_my_proc_id()) {
|
||||
*rva = va;
|
||||
MEMHEAP_VERBOSE_FASTPATH(10, "rkey: pe=%d va=%p -> (local) %lx %p", pe, (void *)va,
|
||||
s->mkeys[btl_id].key, (void *)*rva);
|
||||
MEMHEAP_VERBOSE_FASTPATH(10, "rkey: pe=%d va=%p -> (local) %lx %p", pe, va,
|
||||
s->mkeys[btl_id].key, *rva);
|
||||
return &s->mkeys[btl_id];
|
||||
}
|
||||
|
||||
@ -581,7 +581,7 @@ mca_spml_mkey_t * mca_memheap_base_get_cached_mkey(int pe,
|
||||
return mkey;
|
||||
}
|
||||
|
||||
mca_spml_mkey_t *mca_memheap_base_get_mkey(unsigned long va, int tr_id)
|
||||
mca_spml_mkey_t *mca_memheap_base_get_mkey(void* va, int tr_id)
|
||||
{
|
||||
map_segment_t *s;
|
||||
|
||||
@ -592,8 +592,8 @@ mca_spml_mkey_t *mca_memheap_base_get_mkey(unsigned long va, int tr_id)
|
||||
|
||||
uint64_t mca_memheap_base_find_offset(int pe,
|
||||
int tr_id,
|
||||
unsigned long va,
|
||||
uint64_t rva)
|
||||
void* va,
|
||||
void* rva)
|
||||
{
|
||||
map_segment_t *s;
|
||||
|
||||
@ -602,12 +602,12 @@ uint64_t mca_memheap_base_find_offset(int pe,
|
||||
return ((s && s->is_active) ? (rva - s->mkeys_cache[pe][tr_id].va_base) : 0);
|
||||
}
|
||||
|
||||
int mca_memheap_base_is_symmetric_addr(unsigned long va)
|
||||
int mca_memheap_base_is_symmetric_addr(const void* va)
|
||||
{
|
||||
return (__find_va(va) ? 1 : 0);
|
||||
}
|
||||
|
||||
int mca_memheap_base_detect_addr_type(unsigned long va)
|
||||
int mca_memheap_base_detect_addr_type(void* va)
|
||||
{
|
||||
int addr_type = ADDR_INVALID;
|
||||
map_segment_t *s;
|
||||
@ -617,11 +617,11 @@ int mca_memheap_base_detect_addr_type(unsigned long va)
|
||||
if (s) {
|
||||
if (s->type == MAP_SEGMENT_STATIC) {
|
||||
addr_type = ADDR_STATIC;
|
||||
} else if (va >= (unsigned long) s->start
|
||||
&& va < (unsigned long) (s->start + mca_memheap.memheap_size)) {
|
||||
} else if ((uintptr_t)va >= (uintptr_t) s->start
|
||||
&& (uintptr_t)va < (uintptr_t) (s->start + mca_memheap.memheap_size)) {
|
||||
addr_type = ADDR_USER;
|
||||
} else {
|
||||
assert( va >= (unsigned long)(s->start + mca_memheap.memheap_size) && va < (unsigned long)s->end);
|
||||
assert( (uintptr_t)va >= (uintptr_t)(s->start + mca_memheap.memheap_size) && (uintptr_t)va < (uintptr_t)s->end);
|
||||
addr_type = ADDR_PRIVATE;
|
||||
}
|
||||
}
|
||||
|
||||
@ -27,10 +27,10 @@ int mca_memheap_base_reg(mca_memheap_map_t *memheap_map)
|
||||
map_segment_t *s = &memheap_map->mem_segs[i];
|
||||
|
||||
MEMHEAP_VERBOSE(5,
|
||||
"register seg#%02d: 0x%llX - 0x%llX %llu bytes type=0x%X id=0x%X",
|
||||
"register seg#%02d: 0x%p - 0x%p %llu bytes type=0x%X id=0x%X",
|
||||
i,
|
||||
(long long)s->start,
|
||||
(long long)s->end,
|
||||
s->start,
|
||||
s->end,
|
||||
(long long)(s->end - s->start),
|
||||
s->type,
|
||||
s->shmid);
|
||||
@ -52,10 +52,10 @@ int mca_memheap_base_dereg(mca_memheap_map_t *memheap_map)
|
||||
continue;
|
||||
|
||||
MEMHEAP_VERBOSE(5,
|
||||
"deregistering segment#%d: %llx - %llx %llu bytes",
|
||||
"deregistering segment#%d: %p - %p %llu bytes",
|
||||
i,
|
||||
(long long)s->start,
|
||||
(long long)s->end,
|
||||
s->start,
|
||||
s->end,
|
||||
(long long)(s->end - s->start));
|
||||
ret = __dereg_segment(s);
|
||||
}
|
||||
|
||||
@ -16,8 +16,8 @@
|
||||
#include <stdio.h>
|
||||
|
||||
struct map_segment_desc {
|
||||
uint64_t start;
|
||||
uint64_t end;
|
||||
void* start;
|
||||
void* end;
|
||||
char perms[8];
|
||||
uint64_t offset;
|
||||
char dev[8];
|
||||
@ -27,8 +27,8 @@ struct map_segment_desc {
|
||||
|
||||
typedef struct memheap_static_context {
|
||||
struct {
|
||||
uint64_t start;
|
||||
uint64_t end;
|
||||
void* start;
|
||||
void* end;
|
||||
} mem_segs[MCA_MEMHEAP_MAX_SEGMENTS];
|
||||
int n_segments;
|
||||
} memheap_static_context_t;
|
||||
@ -93,7 +93,7 @@ static int __check_perms(struct map_segment_desc *seg)
|
||||
static int __check_address(struct map_segment_desc *seg)
|
||||
{
|
||||
extern unsigned _end;
|
||||
unsigned long data_end = (unsigned long) &_end;
|
||||
void* data_end = &_end;
|
||||
|
||||
/**
|
||||
* SGI shmem only supports globals&static in main program.
|
||||
@ -104,10 +104,10 @@ static int __check_address(struct map_segment_desc *seg)
|
||||
* FIXME: make sure we do not register symmetric heap twice
|
||||
* if we decide to allow shared objects
|
||||
*/
|
||||
if (seg->start > data_end) {
|
||||
if ((uintptr_t)seg->start > (uintptr_t)data_end) {
|
||||
MEMHEAP_VERBOSE(100,
|
||||
"skip segment: data _end < segment start (%llx < %llx)",
|
||||
(unsigned long long)data_end, (unsigned long long)seg->start);
|
||||
"skip segment: data _end < segment start (%p < %p)",
|
||||
data_end, seg->start);
|
||||
return OSHMEM_ERROR;
|
||||
}
|
||||
return OSHMEM_SUCCESS;
|
||||
|
||||
@ -90,13 +90,12 @@ static inline int test_bit(int nr, const volatile void * addr)
|
||||
static inline __opal_attribute_always_inline__ unsigned long __ffs(unsigned long word)
|
||||
{
|
||||
int num = 0;
|
||||
|
||||
if(bits_per_long() == 64) {
|
||||
#if __SIZEOF_LONG__ == 8
|
||||
if ((word & 0xffffffff) == 0) {
|
||||
num += 32;
|
||||
word >>= 32;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
if ((word & 0xffff) == 0) {
|
||||
num += 16;
|
||||
|
||||
@ -58,18 +58,18 @@ typedef int (*mca_memheap_base_module_free_fn_t)(void*);
|
||||
*/
|
||||
typedef uint64_t (*mca_memheap_base_module_find_offset_fn_t)(int pe,
|
||||
int tr_id,
|
||||
unsigned long va,
|
||||
uint64_t rva);
|
||||
void* va,
|
||||
void* rva);
|
||||
|
||||
/**
|
||||
* @return mkey suitable to access pe via given transport id. rva is set to virtual address mapping of (va)
|
||||
* on remote pe.
|
||||
*/
|
||||
typedef mca_spml_mkey_t * (*mca_memheap_base_module_get_cached_mkey_fn_t)(int pe,
|
||||
unsigned long va,
|
||||
void* va,
|
||||
int transport_id,
|
||||
uint64_t *rva);
|
||||
typedef mca_spml_mkey_t * (*mca_memheap_base_module_get_local_mkey_fn_t)(unsigned long va,
|
||||
void** rva);
|
||||
typedef mca_spml_mkey_t * (*mca_memheap_base_module_get_local_mkey_fn_t)(void* va,
|
||||
int transport_id);
|
||||
|
||||
/*
|
||||
@ -77,7 +77,7 @@ typedef mca_spml_mkey_t * (*mca_memheap_base_module_get_local_mkey_fn_t)(unsigne
|
||||
*/
|
||||
typedef int (*mca_memheap_base_module_finalize_fn_t)(void);
|
||||
|
||||
typedef int (*mca_memheap_base_is_memheap_addr_fn_t)(unsigned long va);
|
||||
typedef int (*mca_memheap_base_is_memheap_addr_fn_t)(const void* va);
|
||||
|
||||
/* get mkeys from all ranks */
|
||||
typedef void (*mca_memheap_base_mkey_exchange_fn_t)(void);
|
||||
|
||||
@ -80,7 +80,7 @@ typedef struct mca_spml_mkey {
|
||||
} ib;
|
||||
uint64_t key;
|
||||
};
|
||||
uint64_t va_base;
|
||||
void* va_base;
|
||||
void *spml_context; /* spml module can attach internal structures here */
|
||||
} mca_spml_mkey_t;
|
||||
|
||||
|
||||
@ -98,7 +98,7 @@ static char *btl_type2str(int btl_type)
|
||||
|
||||
static inline void calc_nfrags(mca_bml_base_btl_t* bml_btl,
|
||||
size_t size,
|
||||
int *frag_size,
|
||||
unsigned int *frag_size,
|
||||
int *nfrags,
|
||||
int use_send)
|
||||
{
|
||||
@ -428,11 +428,11 @@ mca_spml_mkey_t *mca_spml_yoda_register(void* addr,
|
||||
}
|
||||
}
|
||||
|
||||
mkeys[i].va_base = (unsigned long) addr;
|
||||
mkeys[i].va_base = addr;
|
||||
|
||||
SPML_VERBOSE(5,
|
||||
"rank %d btl %s rkey %x lkey %x key %llx address 0x%llX len %llu shmid 0x%X|0x%X",
|
||||
oshmem_proc_local_proc->proc_name.vpid, btl_type2str(ybtl->btl_type), mkeys[i].ib.rkey, mkeys[i].ib.lkey, (unsigned long long)mkeys[i].key, (unsigned long long)mkeys[i].va_base, (unsigned long long)size, MEMHEAP_SHM_GET_TYPE(shmid), MEMHEAP_SHM_GET_ID(shmid));
|
||||
"rank %d btl %s rkey %x lkey %x key %llx address 0x%p len %llu shmid 0x%X|0x%X",
|
||||
oshmem_proc_local_proc->proc_name.vpid, btl_type2str(ybtl->btl_type), mkeys[i].ib.rkey, mkeys[i].ib.lkey, (unsigned long long)mkeys[i].key, mkeys[i].va_base, (unsigned long long)size, MEMHEAP_SHM_GET_TYPE(shmid), MEMHEAP_SHM_GET_ID(shmid));
|
||||
}
|
||||
OBJ_DESTRUCT(&convertor);
|
||||
*count = mca_spml_yoda.n_btls;
|
||||
@ -724,10 +724,10 @@ static inline int mca_spml_yoda_put_internal(void *dst_addr,
|
||||
int nfrags;
|
||||
int i;
|
||||
unsigned ncopied = 0;
|
||||
int frag_size = 0;
|
||||
unsigned int frag_size = 0;
|
||||
char *p_src, *p_dst;
|
||||
mca_spml_yoda_context_t* yoda_context;
|
||||
uint64_t rva;
|
||||
void* rva;
|
||||
mca_spml_mkey_t *r_mkey;
|
||||
int btl_id = 0;
|
||||
struct yoda_btl *ybtl;
|
||||
@ -749,7 +749,7 @@ static inline int mca_spml_yoda_put_internal(void *dst_addr,
|
||||
|
||||
/* Get rkey of remote PE (dst proc) which must be on memheap*/
|
||||
r_mkey = mca_memheap.memheap_get_cached_mkey(dst,
|
||||
(unsigned long) dst_addr,
|
||||
dst_addr,
|
||||
btl_id,
|
||||
&rva);
|
||||
if (!r_mkey) {
|
||||
@ -769,7 +769,7 @@ static inline int mca_spml_yoda_put_internal(void *dst_addr,
|
||||
* just do memcpy
|
||||
*/
|
||||
if ((ybtl->btl_type == YODA_BTL_SM)
|
||||
&& OPAL_LIKELY(mca_memheap.memheap_is_symmetric_addr((unsigned long)dst_addr) && (unsigned long)dst_addr != rva)) {
|
||||
&& OPAL_LIKELY(mca_memheap.memheap_is_symmetric_addr(dst_addr) && dst_addr != rva)) {
|
||||
memcpy((void *) (unsigned long) rva, src_addr, size);
|
||||
return OSHMEM_SUCCESS;
|
||||
}
|
||||
@ -783,7 +783,7 @@ static inline int mca_spml_yoda_put_internal(void *dst_addr,
|
||||
/* Allocating send request from free list */
|
||||
putreq = mca_spml_yoda_putreq_alloc(dst);
|
||||
frag = &putreq->put_frag;
|
||||
ncopied = i < nfrags - 1 ? (unsigned)frag_size : (char *) src_addr + size - p_src;
|
||||
ncopied = i < nfrags - 1 ? frag_size :(unsigned) ((char *) src_addr + size - p_src);
|
||||
|
||||
/* Preparing source buffer */
|
||||
|
||||
@ -993,9 +993,9 @@ int mca_spml_yoda_get(void* src_addr, size_t size, void* dst_addr, int src)
|
||||
{
|
||||
int rc = OSHMEM_SUCCESS;
|
||||
mca_spml_mkey_t *r_mkey, *l_mkey;
|
||||
uint64_t rva;
|
||||
void* rva;
|
||||
unsigned ncopied = 0;
|
||||
int frag_size = 0;
|
||||
unsigned int frag_size = 0;
|
||||
char *p_src, *p_dst;
|
||||
int i;
|
||||
int nfrags;
|
||||
@ -1032,7 +1032,7 @@ int mca_spml_yoda_get(void* src_addr, size_t size, void* dst_addr, int src)
|
||||
|
||||
/* Get rkey of remote PE (src proc) which must be on memheap*/
|
||||
r_mkey = mca_memheap.memheap_get_cached_mkey(src,
|
||||
(unsigned long) src_addr,
|
||||
src_addr,
|
||||
btl_id,
|
||||
&rva);
|
||||
if (!r_mkey) {
|
||||
@ -1053,8 +1053,8 @@ int mca_spml_yoda_get(void* src_addr, size_t size, void* dst_addr, int src)
|
||||
* just do memcpy
|
||||
*/
|
||||
if ((ybtl->btl_type == YODA_BTL_SM)
|
||||
&& OPAL_LIKELY(mca_memheap.memheap_is_symmetric_addr((unsigned long)src_addr) && (unsigned long)src_addr != rva)) {
|
||||
memcpy(dst_addr, (void *) (unsigned long) rva, size);
|
||||
&& OPAL_LIKELY(mca_memheap.memheap_is_symmetric_addr(src_addr) && src_addr != rva)) {
|
||||
memcpy(dst_addr, (void *) rva, size);
|
||||
/* must call progress here to avoid deadlock. Scenarion:
|
||||
* pe1 pols pe2 via shm get. pe2 tries to get static variable from node one, which goes to sm btl
|
||||
* In this case pe2 is stuck forever because pe1 never calls opal_progress.
|
||||
@ -1064,13 +1064,13 @@ int mca_spml_yoda_get(void* src_addr, size_t size, void* dst_addr, int src)
|
||||
return OSHMEM_SUCCESS;
|
||||
}
|
||||
|
||||
l_mkey = mca_memheap.memheap_get_local_mkey((unsigned long) dst_addr,
|
||||
l_mkey = mca_memheap.memheap_get_local_mkey(dst_addr,
|
||||
btl_id);
|
||||
/*
|
||||
* Need a copy if local memory has not been registered or
|
||||
* we make GET via SEND
|
||||
*/
|
||||
frag_size = (int)ncopied;
|
||||
frag_size = ncopied;
|
||||
if ((NULL == l_mkey) || get_via_send)
|
||||
{
|
||||
calc_nfrags(bml_btl, size, &frag_size, &nfrags, get_via_send);
|
||||
@ -1091,7 +1091,7 @@ int mca_spml_yoda_get(void* src_addr, size_t size, void* dst_addr, int src)
|
||||
frag = &getreq->get_frag;
|
||||
getreq->parent = &get_holder;
|
||||
|
||||
ncopied = i < nfrags - 1 ? (unsigned)frag_size : (char *) dst_addr + size - p_dst;
|
||||
ncopied = i < nfrags - 1 ? frag_size :(unsigned) ((char *) dst_addr + size - p_dst);
|
||||
frag->allocated = 0;
|
||||
/* Prepare destination descriptor*/
|
||||
yoda_context = r_mkey->spml_context;
|
||||
|
||||
@ -189,7 +189,9 @@ FUNC_OP_CREATE(max, fint4, ompi_fortran_integer4_t, __max_op);
|
||||
FUNC_OP_CREATE(max, fint8, ompi_fortran_integer8_t, __max_op);
|
||||
FUNC_OP_CREATE(max, freal4, ompi_fortran_real4_t, __max_op);
|
||||
FUNC_OP_CREATE(max, freal8, ompi_fortran_real8_t, __max_op);
|
||||
#if ompi_fortran_real16_t
|
||||
FUNC_OP_CREATE(max, freal16, ompi_fortran_real16_t, __max_op);
|
||||
#endif
|
||||
|
||||
/* MIN */
|
||||
#define __min_op(a, b) ((a) < (b) ? (a) : (b))
|
||||
@ -204,7 +206,9 @@ FUNC_OP_CREATE(min, fint4, ompi_fortran_integer4_t, __min_op);
|
||||
FUNC_OP_CREATE(min, fint8, ompi_fortran_integer8_t, __min_op);
|
||||
FUNC_OP_CREATE(min, freal4, ompi_fortran_real4_t, __min_op);
|
||||
FUNC_OP_CREATE(min, freal8, ompi_fortran_real8_t, __min_op);
|
||||
#if ompi_fortran_real16_t
|
||||
FUNC_OP_CREATE(min, freal16, ompi_fortran_real16_t, __min_op);
|
||||
#endif
|
||||
|
||||
/* SUM */
|
||||
#define __sum_op(a, b) ((a) + (b))
|
||||
@ -221,7 +225,9 @@ FUNC_OP_CREATE(sum, fint4, ompi_fortran_integer4_t, __sum_op);
|
||||
FUNC_OP_CREATE(sum, fint8, ompi_fortran_integer8_t, __sum_op);
|
||||
FUNC_OP_CREATE(sum, freal4, ompi_fortran_real4_t, __sum_op);
|
||||
FUNC_OP_CREATE(sum, freal8, ompi_fortran_real8_t, __sum_op);
|
||||
#if ompi_fortran_real16_t
|
||||
FUNC_OP_CREATE(sum, freal16, ompi_fortran_real16_t, __sum_op);
|
||||
#endif
|
||||
|
||||
/* PROD */
|
||||
#define __prod_op(a, b) ((a) * (b))
|
||||
@ -238,7 +244,9 @@ FUNC_OP_CREATE(prod, fint4, ompi_fortran_integer4_t, __prod_op);
|
||||
FUNC_OP_CREATE(prod, fint8, ompi_fortran_integer8_t, __prod_op);
|
||||
FUNC_OP_CREATE(prod, freal4, ompi_fortran_real4_t, __prod_op);
|
||||
FUNC_OP_CREATE(prod, freal8, ompi_fortran_real8_t, __prod_op);
|
||||
#if ompi_fortran_real16_t
|
||||
FUNC_OP_CREATE(prod, freal16, ompi_fortran_real16_t, __prod_op);
|
||||
#endif
|
||||
|
||||
int oshmem_op_init(void)
|
||||
{
|
||||
@ -289,7 +297,9 @@ int oshmem_op_init(void)
|
||||
OBJ_OP_CREATE(max, fint8, ompi_fortran_integer8_t, OSHMEM_OP_MAX, OSHMEM_OP_TYPE_FINT8);
|
||||
OBJ_OP_CREATE(max, freal4, ompi_fortran_real4_t, OSHMEM_OP_MAX, OSHMEM_OP_TYPE_FREAL4);
|
||||
OBJ_OP_CREATE(max, freal8, ompi_fortran_real8_t, OSHMEM_OP_MAX, OSHMEM_OP_TYPE_FREAL8);
|
||||
#if ompi_fortran_real16_t
|
||||
OBJ_OP_CREATE(max, freal16, ompi_fortran_real16_t, OSHMEM_OP_MAX, OSHMEM_OP_TYPE_FREAL16);
|
||||
#endif
|
||||
|
||||
/* MIN */
|
||||
OBJ_OP_CREATE(min, short, short, OSHMEM_OP_MIN, OSHMEM_OP_TYPE_SHORT);
|
||||
@ -303,7 +313,9 @@ int oshmem_op_init(void)
|
||||
OBJ_OP_CREATE(min, fint8, ompi_fortran_integer8_t, OSHMEM_OP_MIN, OSHMEM_OP_TYPE_FINT8);
|
||||
OBJ_OP_CREATE(min, freal4, ompi_fortran_real4_t, OSHMEM_OP_MIN, OSHMEM_OP_TYPE_FREAL4);
|
||||
OBJ_OP_CREATE(min, freal8, ompi_fortran_real8_t, OSHMEM_OP_MIN, OSHMEM_OP_TYPE_FREAL8);
|
||||
#if ompi_fortran_real16_t
|
||||
OBJ_OP_CREATE(min, freal16, ompi_fortran_real16_t, OSHMEM_OP_MIN, OSHMEM_OP_TYPE_FREAL16);
|
||||
#endif
|
||||
|
||||
/* SUM */
|
||||
OBJ_OP_CREATE(sum, short, short, OSHMEM_OP_SUM, OSHMEM_OP_TYPE_SHORT);
|
||||
@ -319,7 +331,9 @@ int oshmem_op_init(void)
|
||||
OBJ_OP_CREATE(sum, fint8, ompi_fortran_integer8_t, OSHMEM_OP_SUM, OSHMEM_OP_TYPE_FINT8);
|
||||
OBJ_OP_CREATE(sum, freal4, ompi_fortran_real4_t, OSHMEM_OP_SUM, OSHMEM_OP_TYPE_FREAL4);
|
||||
OBJ_OP_CREATE(sum, freal8, ompi_fortran_real8_t, OSHMEM_OP_SUM, OSHMEM_OP_TYPE_FREAL8);
|
||||
#if ompi_fortran_real16_t
|
||||
OBJ_OP_CREATE(sum, freal16, ompi_fortran_real16_t, OSHMEM_OP_SUM, OSHMEM_OP_TYPE_FREAL16);
|
||||
#endif
|
||||
|
||||
/* PROD */
|
||||
OBJ_OP_CREATE(prod, short, short, OSHMEM_OP_PROD, OSHMEM_OP_TYPE_SHORT);
|
||||
@ -335,7 +349,9 @@ int oshmem_op_init(void)
|
||||
OBJ_OP_CREATE(prod, fint8, ompi_fortran_integer8_t, OSHMEM_OP_PROD, OSHMEM_OP_TYPE_FINT8);
|
||||
OBJ_OP_CREATE(prod, freal4, ompi_fortran_real4_t, OSHMEM_OP_PROD, OSHMEM_OP_TYPE_FREAL4);
|
||||
OBJ_OP_CREATE(prod, freal8, ompi_fortran_real8_t, OSHMEM_OP_PROD, OSHMEM_OP_TYPE_FREAL8);
|
||||
#if ompi_fortran_real16_t
|
||||
OBJ_OP_CREATE(prod, freal16, ompi_fortran_real16_t, OSHMEM_OP_PROD, OSHMEM_OP_TYPE_FREAL16);
|
||||
#endif
|
||||
|
||||
return OSHMEM_SUCCESS;
|
||||
}
|
||||
|
||||
@ -177,7 +177,7 @@ OSHMEM_DECLSPEC int oshmem_shmem_register_params(void);
|
||||
*/
|
||||
#include "oshmem/mca/memheap/memheap.h"
|
||||
#define RUNTIME_CHECK_ADDR(x) \
|
||||
if (OPAL_UNLIKELY(!MCA_MEMHEAP_CALL(is_symmetric_addr((unsigned long)(x))))) \
|
||||
if (OPAL_UNLIKELY(!MCA_MEMHEAP_CALL(is_symmetric_addr((x))))) \
|
||||
{ \
|
||||
RUNTIME_CHECK_ERROR("Required address %p is not in symmetric space\n", (x)); \
|
||||
oshmem_shmem_abort(-1); \
|
||||
|
||||
@ -17,12 +17,12 @@
|
||||
|
||||
int shmem_addr_accessible(void *addr, int pe)
|
||||
{
|
||||
uint64_t rva;
|
||||
void* rva;
|
||||
mca_spml_mkey_t *mkey;
|
||||
|
||||
RUNTIME_CHECK_INIT();
|
||||
|
||||
mkey = MCA_MEMHEAP_CALL(get_cached_mkey(pe, (unsigned long)addr,
|
||||
mkey = MCA_MEMHEAP_CALL(get_cached_mkey(pe, addr,
|
||||
oshmem_get_transport_id(pe), &rva));
|
||||
|
||||
return mkey ? 1 : 0;
|
||||
|
||||
@ -11,7 +11,7 @@
|
||||
#ifndef SHMEM_FORTRAN_POINTER_H
|
||||
#define SHMEM_FORTRAN_POINTER_H
|
||||
|
||||
#define FORTRAN_POINTER_T uint64_t
|
||||
#define FORTRAN_POINTER_T uintptr_t
|
||||
#define FPTR_2_VOID_PTR(a) ((void *)(a))
|
||||
|
||||
#endif
|
||||
|
||||
Загрузка…
x
Ссылка в новой задаче
Block a user