int main(int argc, char *argv[]) {
int n = 100;
// int n1=101;
start_pes(0);
int nn = (n-1) / _num_pes();
int n_local0 = 1 + _my_pe() * nn;
int n_local1 = 1 + (_my_pe()+1) * nn;
// allocate only local part + ghost zone of the arrays x,y
float *x, *y;
x = (float*) malloc((n_local1 - n_local0 + 2)*sizeof(float));
y = (float*) malloc((n_local1 - n_local0 + 2)*sizeof(float)); // forgot shmalloc
shmem_barrier_all();
//... // fill x, y
// fill ghost zone
if (_my_pe() > 0)
shmem_float_get(x,y,n1,1); // extra code
shmem_float_put(y,x, 1, _my_pe()-1);
shmem_barrier_all();
// do computation
float e = 0;
int i;
for (i=n_local0; i<n_local1; ++i) {
x[i] += ( y[i+1] + y[i-1] )*.5;
e += y[i] * y[i];
}
static float work[_SHMEM_REDUCE_SYNC_SIZE];
static long sync[_SHMEM_REDUCE_SYNC_SIZE];
static float el, es;
el = e;
shmem_float_sum_to_all(&es, &el, 1,
0, 0, _num_pes(), work, sync);
e = es;
// ... // output x, e
x += (n_local0 - 1);
y += (n_local0 - 1);
shfree(x);
shfree(y);
return 0;
}
/*
* _glio_group_init
*
* Initialize a group based on the type of program we're called from.
*/
void
_glio_group_init(glio_group_t *gg)
{
int groupsz, myrank;
if (gg->grtype != GR_DEFAULT)
return;
switch (_glio_progtype()) {
case GR_SHMEM:
gg->grtype = GR_SHMEM;
gg->groupsz = _num_pes();
gg->myrank = _my_pe();
gg->u.shmem.group = SHMEM_GROUP_WORLD;
break;
case GR_MPI:
gg->grtype = GR_MPI;
ckMPIerr( MPI_Comm_size(MPI_COMM_WORLD, &groupsz) );
gg->groupsz = groupsz;
ckMPIerr( MPI_Comm_rank(MPI_COMM_WORLD, &myrank) );
gg->myrank = myrank;
gg->u.MPI.comm = MPI_COMM_WORLD;
break;
default:
gg->grtype = GR_ONE;
gg->groupsz = 1;
gg->myrank = 0;
break;
}
}
int shmem_pe_accessible(int pe)
{
RUNTIME_CHECK_INIT();
/* Assume that everything between 0 and num_pes() is reachable. */
return 0 <= pe && pe < _num_pes() ? 1 : 0;
}
int oshmem_shmem_preconnect_all(void)
{
int rc = OSHMEM_SUCCESS;
/* force qp creation and rkey exchange for memheap. Does not force exchange of static vars */
if (oshmem_preconnect_all) {
long val;
int nproc = 0;
int i;
val = 0xdeadbeaf;
if (!preconnect_value) {
rc =
MCA_MEMHEAP_CALL(private_alloc(sizeof(long), (void **)&preconnect_value));
}
if (!preconnect_value || (rc != OSHMEM_SUCCESS)) {
SHMEM_API_ERROR("shmem_preconnect_all failed");
return OSHMEM_ERR_OUT_OF_RESOURCE;
}
nproc = _num_pes();
for (i = 0; i < nproc; i++) {
shmem_long_p(preconnect_value, val, i);
}
shmem_fence();
shmem_barrier_all();
SHMEM_API_VERBOSE(5, "Preconnected all PEs");
}
return OSHMEM_SUCCESS;
}
/* Performance test for shmem_broadcast32 */
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <sys/time.h>
#include <shmem.h>
long pSyncA[_SHMEM_BCAST_SYNC_SIZE];
long pSyncB[_SHMEM_BCAST_SYNC_SIZE];
#define N_ELEMENTS 25600/*Data size chosen to be able to capture time required*/
int
main(void)
{
int i,j,k;
int *target;
int *source;
int me, npes;
struct timeval start, end;
long time_taken,start_time,end_time;
start_pes(0);
me = _my_pe();
npes = _num_pes();
source = (int *) shmalloc( N_ELEMENTS * sizeof(*source) );
time_taken = 0;
for (i = 0; i < N_ELEMENTS; i += 1) {
source[i] = i + 1;
}
target = (int *) shmalloc( N_ELEMENTS * sizeof(*target) );
for (i = 0; i < N_ELEMENTS; i += 1) {
target[i] = -90;
}
for (i = 0; i < _SHMEM_BCAST_SYNC_SIZE; i += 1) {
pSyncA[i] = _SHMEM_SYNC_VALUE;
pSyncB[i] = _SHMEM_SYNC_VALUE;
}
shmem_barrier_all();
for(i=0;i<10000;i++){
gettimeofday(&start, NULL);
start_time = (start.tv_sec * 1000000.0) + start.tv_usec;
/* alternate between 2 pSync arrays to synchronize
* consequent collectives of even and odd iterations */
if(i % 2)
shmem_broadcast32(target, source, N_ELEMENTS, 0, 0, 0, npes, pSyncA);
else
shmem_broadcast32(target, source, N_ELEMENTS, 0, 0, 0, npes, pSyncB);
gettimeofday(&end, NULL);
end_time = (end.tv_sec * 1000000.0) + end.tv_usec;
if(me==0){
time_taken = time_taken + (end_time - start_time);
}
}
if(me == 0)
printf("Time required for a broadcast of 100 Kbytes of data, with %d PEs is %ld microseconds\n",npes,time_taken/10000);
shmem_barrier_all();
shfree(target);
shfree(source);
return 0;
}
/* platform specific initialization */
void vt_pform_init() {
struct timeval tp;
static ApTeam_t app;
int i;
#if TIMER == TIMER_RTC
vt_ticks_per_sec = (uint64_t)sysconf(_SC_SV2_USER_TIME_RATE);
# pragma omp parallel
{
gettimeofday(&tp, 0);
vt_rtc_base = _rtc();
}
#elif TIMER == TIMER_GETTIMEOFDAY
gettimeofday(&tp, 0);
vt_time_base = tp.tv_sec - (tp.tv_sec & 0xFFFF);
#elif TIMER == TIMER_PAPI_REAL_USEC
vt_time_base = vt_metric_real_usec();
#endif
if (apteamctl(ApTeam_Status, 0, 0, &app) == 1) {
vt_mspmode = (app.flags & APTEAM_MSP);
app.pes = (ApPe_t*)malloc(app.pecount * sizeof(ApPe_t));
if (apteamctl(ApTeam_Status, 0, 0, &app) == 1) {
for (i=0; i<_num_pes(); i++) {
if (_my_pe() == app.pes[i].lpe) vt_nodeid = (long)app.pes[i].place;
}
}
}
}
static int test_item2(void)
{
int rc = TC_PASS;
TYPE_VALUE* shmem_addr = NULL;
TYPE_VALUE my_value = 0;
TYPE_VALUE peer_value = 0;
TYPE_VALUE expect_value = 0;
int num_proc = 0;
int my_proc = 0;
int peer_proc = 0;
num_proc = _num_pes();
my_proc = _my_pe();
shmem_addr = shmalloc(sizeof(*shmem_addr));
if (shmem_addr)
{
TYPE_VALUE value = -1;
/* Set my value */
my_value = (-1);
*shmem_addr = my_value;
/* Define peer and it value */
peer_proc = (my_proc + 1) % num_proc;
peer_value = (TYPE_VALUE)my_proc;
/* Define expected value */
expect_value = (TYPE_VALUE)(my_proc ? (my_proc - 1) : (num_proc - 1));
/* This guarantees that PE set initial value before peer change one */
shmem_barrier_all();
/* Write value to peer */
FUNC_VALUE(shmem_addr, peer_value, peer_proc);
/* Get value put by peer:
* These routines start the remote transfer and may return before the data
* is delivered to the remote PE
*/
wait_for_put_completion(peer_proc,10 /* wait for 10 secs */);
value = *shmem_addr;
rc = (sys_fcompare(expect_value, value) ? TC_PASS : TC_FAIL);
log_debug(OSH_TC, "my(#%d:%Lf) peer(#%d:%Lf) expected = %Lf vs got = %Lf\n",
my_proc, (long double)my_value, peer_proc, (long double)peer_value, (long double)expect_value, (long double)value);
}
else
{
rc = TC_SETUP_FAIL;
}
if (shmem_addr)
{
shfree(shmem_addr);
}
return rc;
}
int main(int argc, char * argv[])
{
/* Get PE information */
shmem_init();
me = _my_pe();
npes = _num_pes();
/* Initialize and send on PE 0 */
if (me == 0) {
for (i = 0; i < 8; i++)
src[i] = i + 1;
/* Put source date at PE 0 to dest at PE 1+ */
for (i = 1; i < npes; i++)
shmem_put64(dest, src, 8 * sizeof(int) / 8, i);
}
/* Make sure the transfer is complete */
shmem_barrier_all();
/* Print from PE 1+ */
if (me > 0) {
printf("PE %d: %d", me, dest[0]);
for (i = 1; i < 8; i++)
printf(",%d", dest[i]);
printf("\n");
}
shmem_finalize();
return 0;
}
int
main(int argc, char* argv[])
{
int i, Verbose=0;
char *pgm;
if ((pgm=strrchr(argv[0],'/')))
pgm++;
else
pgm = argv[0];
if (argc > 1) {
if (strncmp(argv[1],"-v",3) == 0)
Verbose=1;
else if (strncmp(argv[1],"-h",3) == 0) {
fprintf(stderr,"usage: %s {v(verbose)|h(help)}\n",pgm);
exit(1);
}
}
for (i = 0; i < _SHMEM_REDUCE_SYNC_SIZE; i += 1) {
pSync[i] = _SHMEM_SYNC_VALUE;
}
start_pes(0);
for (i = 0; i < N; i += 1) {
src[i] = _my_pe() + i;
}
shmem_barrier_all();
shmem_long_max_to_all(dst, src, N, 0, 0, _num_pes(), pWrk, pSync);
if (Verbose) {
printf("%d/%d dst =", _my_pe(), _num_pes() );
for (i = 0; i < N; i+= 1) {
printf(" %ld", dst[i]);
}
printf("\n");
}
for (i = 0; i < N; i+= 1) {
if (dst[i] != _num_pes() - 1 + i) return 1;
}
return 0;
}
int osh_coll_tc3(const TE_NODE *node, int argc, const char *argv[])
{
/* General initialisations */
int ii, numprocs, master;
static int32_t source[10] = { 1, 2, 3, 4, 5,
6, 7, 8, 9, 10
};
static int32_t target[10];
int nlong;
long *pSync = 0;
int status = TC_PASS;
UNREFERENCED_PARAMETER(node);
UNREFERENCED_PARAMETER(argc);
UNREFERENCED_PARAMETER(argv);
numprocs = _num_pes();
master = 1;
nlong = 10;
if (numprocs == 1)
{
log_debug(OSH_TC, "Using more than 1 CPU makes the tests of this program more interesting\n");
return TC_SETUP_FAIL;
}
for (ii = 0; ii < nlong; ii++)
target[ii] = 0;
pSync = NULL;
pSync = shmalloc(sizeof(long) *_SHMEM_COLLECT_SYNC_SIZE);
for (ii=0; ii < _SHMEM_COLLECT_SYNC_SIZE; ii++) {
pSync[ii] = _SHMEM_SYNC_VALUE;
}
shmem_barrier_all(); /* Wait for all CPUs to initialize pSync */
/* Broadcast function */
if (_my_pe()%2 == 1)
shmem_broadcast32(target, source, nlong, 0, 1, 1,
numprocs/2, pSync); /* local master CPU = 0 */
if ((_my_pe()%2 == 1) && (_my_pe() != master))
for (ii = 0; ii < nlong; ii++)
if (target[ii] != (ii + 1))
status = TC_FAIL;
if (pSync) {
shfree(pSync);
}
return status;
}
static int test_item2(void)
{
int rc = TC_PASS;
TYPE_VALUE* shmem_addr = NULL;
TYPE_VALUE my_value = 0;
TYPE_VALUE expect_value = 0;
int num_proc = 0;
int my_proc = 0;
int peer_proc = 0;
int i = 0;
num_proc = _num_pes();
my_proc = _my_pe();
shmem_addr = shmalloc(sizeof(*shmem_addr));
if (shmem_addr)
{
TYPE_VALUE value = 0;
/* Store my value */
my_value = (TYPE_VALUE)my_proc;
*shmem_addr = 0;
/* Define peer */
peer_proc = (my_proc + 1) % num_proc;
/* Define expected value */
expect_value = ( my_proc == 0 ? (num_proc - 1) * __cycle_count : (my_proc - 1) * __cycle_count);
shmem_barrier_all();
for (i = 0; (i < __cycle_count) && (rc == TC_PASS); i++)
{
value = FUNC_VALUE(shmem_addr, my_value, peer_proc);
if (value != (my_value * i))
{
break;
}
}
shmem_barrier_all();
value = *shmem_addr;
rc = (expect_value == value ? TC_PASS : TC_FAIL);
log_debug(OSH_TC, "my(#%d:%lld) expected = %lld vs got = %lld\n",
my_proc, (INT64_TYPE)my_value, (INT64_TYPE)expect_value, (INT64_TYPE)value);
}
else
{
rc = TC_SETUP_FAIL;
}
if (shmem_addr)
{
shfree(shmem_addr);
}
return rc;
}
/****************************************************************************
* Place for Test Item functions
***************************************************************************/
static int test_item1(void)
{
int rc = TC_PASS;
TYPE_VALUE* shmem_addr = NULL;
TYPE_VALUE my_value = 0;
TYPE_VALUE expect_value = 0;
int num_proc = 0;
int my_proc = 0;
int peer_proc = 0;
int i = 0;
num_proc = _num_pes();
my_proc = _my_pe();
shmem_addr = shmalloc(sizeof(*shmem_addr));
if (shmem_addr)
{
TYPE_VALUE value = 0;
/* Store my value */
my_value = (TYPE_VALUE)my_proc;
*shmem_addr = DEFAULT_VALUE;
/* Define peer */
peer_proc = (my_proc + 1) % num_proc;
/* Define expected value */
expect_value = (TYPE_VALUE)(( my_proc == 0 ? (num_proc - 1) : (my_proc - 1) ) + (__cycle_count - 1));
shmem_barrier_all();
for (i = 0; (i < __cycle_count) && (rc == TC_PASS); i++)
{
value = FUNC_VALUE(shmem_addr, (my_value + i), peer_proc);
if ( ((i >0 ) && (!sys_fcompare(value, my_value + i - 1))) || ((i == 0) && (!sys_fcompare(value, DEFAULT_VALUE))) )
{
break;
}
}
shmem_barrier_all();
value = *shmem_addr;
rc = (sys_fcompare(expect_value, value) ? TC_PASS : TC_FAIL);
log_debug(OSH_TC, "my(#%d:%Lf) expected = %Lf vs got = %Lf\n",
my_proc, (long double)my_value, (long double)expect_value, (long double)value);
}
else
{
rc = TC_SETUP_FAIL;
}
if (shmem_addr)
{
shfree(shmem_addr);
}
return rc;
}
/* OP to root, allocated */
static int test_item1(void)
{
int rc = TC_PASS;
TYPE_VALUE* shmem_addr = NULL;
TYPE_VALUE my_value = 0;
TYPE_VALUE expect_value = 0;
int num_proc = 0;
int my_proc = 0;
int root_proc = 0;
int i;
int j;
num_proc = _num_pes();
my_proc = _my_pe();
shmem_addr = shmalloc(sizeof(*shmem_addr));
if (shmem_addr)
{
TYPE_VALUE value = 0;
/* Store my value */
my_value = (TYPE_VALUE)PROC_VALUE(my_proc);
*shmem_addr = 0;
/* Define expected value */
if (my_proc == root_proc) {
/* if root proc */
for (j = 0; j < num_proc; j++) {
for (i = 0; i < __cycle_count; i++) {
expect_value ^= PROC_VALUE(i + j);
}
}
}
shmem_barrier_all();
for (i = 0; (i < __cycle_count) && (rc == TC_PASS); i++)
{
FUNC_VALUE(shmem_addr, PROC_VALUE(i + my_proc), root_proc);
}
shmem_barrier_all();
value = *shmem_addr;
rc = (expect_value == value ? TC_PASS : TC_FAIL);
log_debug(OSH_TC, "my(#%d:%lld) expected = %lld vs got = %lld\n",
my_proc, (INT64_TYPE)my_value, (INT64_TYPE)expect_value, (INT64_TYPE)value);
}
else
{
rc = TC_SETUP_FAIL;
}
if (shmem_addr)
{
shfree(shmem_addr);
}
return rc;
}
static int test_item3(void)
{
int rc = TC_PASS;
static TYPE_VALUE shmem_value = 0;
TYPE_VALUE* shmem_addr = &shmem_value;
TYPE_VALUE my_value = 0;
TYPE_VALUE expect_value = 0;
int num_proc = 0;
int my_proc = 0;
int peer_proc = 0;
int i = 0;
num_proc = _num_pes();
my_proc = _my_pe();
{
TYPE_VALUE value = 0;
/* Store my value */
my_value = (TYPE_VALUE)my_proc;
*shmem_addr = DEFAULT_VALUE;
/* Define peer */
peer_proc = (my_proc + 1) % num_proc;
/* Define expected value */
expect_value = ( my_proc == 0 ? (num_proc - 1) : (my_proc - 1) ) + (__cycle_count - 1);
shmem_barrier_all();
for (i = 0; (i < __cycle_count) && (rc == TC_PASS); i++)
{
value = num_proc + __cycle_count;
value = FUNC_VALUE(shmem_addr, value, (my_value + i), peer_proc);
if ( ((i > 0 ) && (value != (my_value + i - 1))) || ((i == 0) && (value != DEFAULT_VALUE)) )
{
break;
}
value = ( i == 0 ? DEFAULT_VALUE : (my_value + i - 1));
value = FUNC_VALUE(shmem_addr, value, (my_value + i), peer_proc);
if ( ((i > 0 ) && (value != (my_value + i - 1))) || ((i == 0) && (value != DEFAULT_VALUE)) )
{
break;
}
}
shmem_barrier_all();
value = *shmem_addr;
rc = (expect_value == value ? TC_PASS : TC_FAIL);
log_debug(OSH_TC, "my(#%d:%lld) expected = %lld vs got = %lld\n",
my_proc, (INT64_TYPE)my_value, (INT64_TYPE)expect_value, (INT64_TYPE)value);
}
return rc;
}
static int test_item2(void)
{
int rc = TC_PASS;
TYPE_VALUE* shmem_addr = NULL;
TYPE_VALUE my_value = {0, 0};
TYPE_VALUE peer_value = {0, 0};
TYPE_VALUE expect_value = {0, 0};
int num_proc = 0;
int my_proc = 0;
int peer_proc = 0;
num_proc = _num_pes();
my_proc = _my_pe();
shmem_addr = shmalloc(sizeof(*shmem_addr));
if (shmem_addr)
{
TYPE_VALUE value = {-1, 0};
/* Set my value */
my_value.field1 = my_proc;
memcpy(shmem_addr, &my_value, sizeof(my_value));
/* Define peer and it value */
peer_proc = (my_proc + 1) % num_proc;
peer_value.field1 = peer_proc;
/* Define expected value */
memcpy(&expect_value, &peer_value, sizeof(peer_value));
/* Wait is set instead of barrier to give some time to all PE for setting their values */
shmem_barrier_all();
/* Get value from peer */
FUNC_VALUE(&value, shmem_addr, 1, peer_proc);
rc = (compare_buffer((unsigned char*)&expect_value, (unsigned char*)&value, sizeof(value), NULL) ? TC_PASS : TC_FAIL);
log_debug(OSH_TC, "my(#%d:%lld.%lld) peer(#%d:%lld.%lld) expected = %lld.%lld actual = %lld.%lld\n",
my_proc, (INT64_TYPE)my_value.field1, (INT64_TYPE)my_value.field2,
peer_proc, (INT64_TYPE)peer_value.field1, (INT64_TYPE)peer_value.field2,
(INT64_TYPE)expect_value.field1, (INT64_TYPE)expect_value.field2,
(INT64_TYPE)value.field1, (INT64_TYPE)value.field2);
}
else
{
rc = TC_SETUP_FAIL;
}
if (shmem_addr)
{
shfree(shmem_addr);
}
return rc;
}
static int test_item1(void)
{
int rc = TC_PASS;
int num_proc = 0;
int my_proc = 0;
int peer;
int size;
char *buf;
int test_byte;
int max_heap_size_per_proc;
num_proc = _num_pes();
my_proc = _my_pe();
peer = (my_proc + 1) % num_proc;
max_heap_size_per_proc = 1L << (sys_log2((memheap_size() * HEAP_USAGE_PERCENT)/ num_proc) - 1);
max_heap_size_per_proc = (max_heap_size_per_proc > MAX_SIZE) ? MAX_SIZE : max_heap_size_per_proc;
buf = (char *)shmalloc(max_heap_size_per_proc * num_proc);
if (!buf)
{
log_error(OSH_TC, "shmalloc(%d)\n", max_heap_size_per_proc * num_proc);
return TC_SETUP_FAIL;
}
size = 1L << sys_log2(num_proc);
size = ((size - 2) > 0) ? size : 4;
log_debug(OSH_TC, "%d: buf = %p size=%d\n", my_proc, buf, size);
for (; size <= max_heap_size_per_proc; size *=2)
{
memset(buf + max_heap_size_per_proc * my_proc, 1 + my_proc % (size - 2), max_heap_size_per_proc);
log_debug(OSH_TC, "\n%d: b4 barrier size = %d\n", my_proc, size);
shmem_barrier_all();
log_debug(OSH_TC, "%d: b4 putmem size = %d %p -> %p\n", my_proc, size,
buf+max_heap_size_per_proc*my_proc, buf + max_heap_size_per_proc * my_proc);
shmem_putmem(buf+max_heap_size_per_proc*my_proc, buf+max_heap_size_per_proc*my_proc, size, peer);
shmem_fence();
test_byte = 0;
log_debug(OSH_TC, "%d: b4 getmem size = %d\n %p <- %p ", my_proc, size,
&test_byte,
buf+max_heap_size_per_proc*peer + size - 1
);
shmem_getmem(&test_byte, buf+max_heap_size_per_proc*my_proc + size - 1, 1, peer);
log_debug(OSH_TC, "%d: after getmem size = %d result=%x\n", my_proc, size, test_byte);
if (test_byte != 1 + my_proc % (size-2))
{
log_error(OSH_TC, "fence failed at size %d got = %x expected = %x\n", size, test_byte, 1 + my_proc % (size-2));
rc = TC_FAIL;
}
}
shfree(buf);
log_debug(OSH_TC, rc == TC_PASS? "passed" : "failed");
return rc;
}
/* OP to neighbour, allocated */
static int test_item2(void)
{
int rc = TC_PASS;
TYPE_VALUE* shmem_addr = NULL;
TYPE_VALUE my_value = DEFAULT_VALUE;
TYPE_VALUE expect_value = DEFAULT_VALUE;
int num_proc = 0;
int my_proc = 0;
int peer_proc = 0;
int i = 0;
num_proc = _num_pes();
my_proc = _my_pe();
peer_proc = (my_proc + 1) % num_proc;
shmem_addr = shmalloc(sizeof(*shmem_addr));
if (shmem_addr)
{
TYPE_VALUE value = 0;
/* Store my value */
*shmem_addr = DEFAULT_VALUE;
for (i = 0; (i < __cycle_count) && (rc == TC_PASS); i++) {
my_value &= PROC_VALUE(i + my_proc + 1);
}
shmem_barrier_all();
for (i = 0; (i < __cycle_count) && (rc == TC_PASS); i++) {
value = FUNC_VALUE(shmem_addr, PROC_VALUE(i + peer_proc + 1), peer_proc);
if (value != expect_value) {
break;
}
expect_value = value & PROC_VALUE(i + peer_proc + 1);
}
shmem_barrier_all();
value = *shmem_addr;
rc = (my_value == value ? TC_PASS : TC_FAIL);
log_debug(OSH_TC, "my(#%d:%lld) expected = %lld vs got = %lld\n",
my_proc, (INT64_TYPE)my_value, (INT64_TYPE)expect_value, (INT64_TYPE)value);
}
else
{
rc = TC_SETUP_FAIL;
}
if (shmem_addr)
{
shfree(shmem_addr);
}
return rc;
}
static int
NC_init_pe(NC *ncp, int basepe) {
if (basepe < 0 || basepe >= _num_pes()) {
return NC_EINVAL; /* invalid base pe */
}
/* initialize common values */
ncp->lock[LOCKNUMREC_VALUE] = 0;
ncp->lock[LOCKNUMREC_LOCK] = 0;
ncp->lock[LOCKNUMREC_SERVING] = 0;
ncp->lock[LOCKNUMREC_BASEPE] = basepe;
return NC_NOERR;
}
static int test_item2(void)
{
int rc = TC_PASS;
TYPE_VALUE* shmem_addr = NULL;
TYPE_VALUE my_value = 0;
TYPE_VALUE peer_value = 0;
TYPE_VALUE expect_value = 0;
int num_proc = 0;
int my_proc = 0;
int peer_proc = 0;
num_proc = _num_pes();
my_proc = _my_pe();
shmem_addr = shmalloc(sizeof(*shmem_addr));
if (shmem_addr)
{
TYPE_VALUE value = -1;
/* Set my value */
my_value = (TYPE_VALUE)my_proc;
*shmem_addr = my_value;
/* Define peer and it value */
peer_proc = (my_proc + 1) % num_proc;
peer_value = (TYPE_VALUE)peer_proc;
/* Define expected value */
expect_value = peer_value;
/* Wait is set instead of barrier to give some time to all PE for setting their values */
shmem_barrier_all();
/* Get value from peer */
FUNC_VALUE(&value, shmem_addr, 1, peer_proc);
rc = (sys_fcompare(expect_value, value) ? TC_PASS : TC_FAIL);
log_debug(OSH_TC, "my(#%d:%Lf) peer(#%d:%Lf) expected = %Lf buffer size = %lld\n",
my_proc, (long double)my_value, peer_proc, (long double)peer_value, (long double)expect_value, (INT64_TYPE)1);
}
else
{
rc = TC_SETUP_FAIL;
}
if (shmem_addr)
{
shfree(shmem_addr);
}
return rc;
}
int osh_basic_tc7(const TE_NODE *node, int argc, const char *argv[])
{
int rc = TC_PASS;
int me = _my_pe();
int num_of_pes = _num_pes();
//static int test_variable = 0;
int value_to_set = 1;
UNREFERENCED_PARAMETER(node);
UNREFERENCED_PARAMETER(argc);
UNREFERENCED_PARAMETER(argv);
//just in case
shmem_barrier_all();
if (num_of_pes < 2)
{
rc = TC_SETUP_FAIL;
goto FreeMemory;
}
//This test is for 2 ranks only
if (me > 1)
{
goto FreeMemory;
}
if (0 == me)
{
int wait_time = 0;
//wait for pe #1 to change my variable
//and do some important work in the while
while (!test_variable && wait_time < 5000000)
{
usleep(1000);
wait_time += 1000;
}
if (!test_variable)
{
rc = TC_FAIL;
}
}
else
{
shmem_int_put(&test_variable, &value_to_set, 1, 0);
}
FreeMemory:
shmem_barrier_all();
return rc;
}
struct pe_vars
init_openshmem (void)
{
struct pe_vars v;
start_pes(0);
v.me = _my_pe();
v.npes = _num_pes();
v.pairs = v.npes / 2;
v.nxtpe = v.me < v.pairs ? v.me + v.pairs : v.me - v.pairs;
return v;
}
int oshmem_shmem_preconnect_all(void)
{
int mca_value = 0;
int rc = OSHMEM_SUCCESS;
(void) mca_base_var_register("oshmem",
"runtime",
NULL,
"preconnect_all",
"Whether to force SHMEM processes to fully "
"wire-up the connections between SHMEM "
"processes during "
"initialization (vs. making connections lazily -- "
"upon the first SHMEM traffic between each "
"process peer pair)",
MCA_BASE_VAR_TYPE_INT,
NULL,
0,
MCA_BASE_VAR_FLAG_SETTABLE,
OPAL_INFO_LVL_9,
MCA_BASE_VAR_SCOPE_READONLY,
&mca_value);
/* force qp creation and rkey exchange for memheap. Does not force exchange of static vars */
if (mca_value) {
long val;
int nproc = 0;
int i;
val = 0xdeadbeaf;
if (!preconnect_value) {
rc =
MCA_MEMHEAP_CALL(private_alloc(sizeof(long), (void **)&preconnect_value));
}
if (!preconnect_value || (rc != OSHMEM_SUCCESS)) {
SHMEM_API_ERROR("shmem_preconnect_all failed");
return OSHMEM_ERR_OUT_OF_RESOURCE;
}
nproc = _num_pes();
for (i = 0; i < nproc; i++) {
shmem_long_p(preconnect_value, val, i);
}
shmem_fence();
shmem_barrier_all();
SHMEM_API_VERBOSE(5, "Preconnected all PEs");
}
return OSHMEM_SUCCESS;
}
static int test_item3(void)
{
int rc = TC_PASS;
static TYPE_VALUE shmem_value = 0;
TYPE_VALUE* shmem_addr = &shmem_value;
TYPE_VALUE my_value = 0;
TYPE_VALUE expect_value = 0;
int num_proc = 0;
int my_proc = 0;
int peer_proc = 0;
int i = 0;
num_proc = _num_pes();
my_proc = _my_pe();
{
TYPE_VALUE value = 0;
/* Store my value */
my_value = (TYPE_VALUE)1;
*shmem_addr = 0;
/* Define peer */
peer_proc = (my_proc + 1) % num_proc;
/* Define expected value */
expect_value = __cycle_count;
shmem_barrier_all();
for (i = 0; (i < __cycle_count) && (rc == TC_PASS); i++)
{
FUNC_VALUE(shmem_addr, peer_proc);
}
shmem_barrier_all();
value = *shmem_addr;
rc = (expect_value == value ? TC_PASS : TC_FAIL);
log_debug(OSH_TC, "my(#%d:%lld) expected = %lld vs got = %lld\n",
my_proc, (INT64_TYPE)my_value, (INT64_TYPE)expect_value, (INT64_TYPE)value);
}
return rc;
}
int main (void)
{
static int aaa, bbb;
int num_pes, my_pe, peer;
start_pes(0);
num_pes = _num_pes();
my_pe = _my_pe();
peer = (my_pe + 1) % num_pes;
printf("Process %d gets message from %d (%d processes in ring)\n", my_pe, peer, num_pes);
shmem_int_get(&aaa, &bbb, 1, peer);
shmem_barrier_all();
printf("Process %d exiting\n", my_pe);
return 0;
}
int main(void)
{
int i, me, npes;
for (i = 0; i < _SHMEM_BARRIER_SYNC_SIZE; i += 1){
pSync[i] = _SHMEM_SYNC_VALUE;
}
start_pes(0);
me = _my_pe();
npes = _num_pes();
if(me % 2 == 0){
x = 1000 + me;
/*put to next even PE in a circular fashion*/
shmem_int_p(&x, 4, (me+2)%npes);
/*synchronize all even pes*/
shmem_barrier(0, 1, (npes/2 + npes%2), pSync);
}
printf("%d: x = %d\n", me, x);
return 0;
}
/*ARGSUSED*/
int
nc_set_base_pe(int ncid, int pe)
{
#if _CRAYMPP && defined(LOCKNUMREC)
int status;
NC *ncp;
shmem_t numrecs;
if ((status = NC_check_id(ncid, &ncp)) != NC_NOERR) {
return status;
}
if (pe < 0 || pe >= _num_pes()) {
return NC_EINVAL; /* invalid base pe */
}
numrecs = (shmem_t) NC_get_numrecs(ncp);
ncp->lock[LOCKNUMREC_VALUE] = (ushmem_t) numrecs;
/* update serving & lock values for a "smooth" transition */
/* note that the "real" server will being doing this as well */
/* as all the rest in the group */
/* must have syncronization before & after this step */
shmem_short_get(
(shmem_t *) ncp->lock + LOCKNUMREC_SERVING,
(shmem_t *) ncp->lock + LOCKNUMREC_SERVING,
1, ncp->lock[LOCKNUMREC_BASEPE]);
shmem_short_get(
(shmem_t *) ncp->lock + LOCKNUMREC_LOCK,
(shmem_t *) ncp->lock + LOCKNUMREC_LOCK,
1, ncp->lock[LOCKNUMREC_BASEPE]);
/* complete transition */
ncp->lock[LOCKNUMREC_BASEPE] = (ushmem_t) pe;
#endif /* _CRAYMPP && LOCKNUMREC */
return NC_NOERR;
}
int
main(void)
{
int me, npes;
setbuf(stdout, NULL);
start_pes(0);
me = _my_pe();
npes = _num_pes();
if (me == 0) {
int i;
for (i = 1; i < npes; i += 1) {
printf("From %d: PE %d is ", me, i);
printf("%s", shmem_pe_accessible(i) ? "" : "NOT ");
printf("accessible\n");
}
}
return 0;
}
/* OP to neighbour, static */
static int test_item3(void)
{
int rc = TC_PASS;
static TYPE_VALUE shmem_value = 0;
TYPE_VALUE* shmem_addr = &shmem_value;
TYPE_VALUE my_value = DEFAULT_VALUE;
int num_proc = 0;
int my_proc = 0;
int peer_proc = 0;
int i = 0;
num_proc = _num_pes();
my_proc = _my_pe();
peer_proc = (my_proc + 1) % num_proc;
TYPE_VALUE value = 0;
/* Store my value */
*shmem_addr = DEFAULT_VALUE;
for (i = 0; (i < __cycle_count) && (rc == TC_PASS); i++) {
my_value |= PROC_VALUE(i + my_proc + 1);
}
shmem_barrier_all();
for (i = 0; (i < __cycle_count) && (rc == TC_PASS); i++) {
FUNC_VALUE(shmem_addr, PROC_VALUE(i + peer_proc + 1), peer_proc);
}
shmem_barrier_all();
value = *shmem_addr;
rc = (my_value == value ? TC_PASS : TC_FAIL);
log_debug(OSH_TC, "my(#%d) expected = %lld vs got = %lld\n",
my_proc, (INT64_TYPE)my_value, (INT64_TYPE)value);
return rc;
}
int
main(int argc, char* argv[])
{
int me, npes;
setbuf(stdout, NULL);
start_pes(0);
me = _my_pe();
npes = _num_pes();
if (me == 0) {
int i;
int verbose = (NULL == getenv("MAKELEVEL")) ? 1 : 0;
for (i = 1; i < npes; i += 1) {
if (verbose) {
printf("From %d: PE %d is ", me, i);
printf("%s", shmem_pe_accessible(i) ? "" : "NOT ");
printf("accessible\n");
}
if (! shmem_pe_accessible(i)) return 1;
}
}
return 0;
}
int main(void)
{
int i, me, npes;
int *target;
start_pes(0);
me = _my_pe();
npes = _num_pes();
source[0] = me * 2;
source[1] = me * 2 + 1;
target = (int *)shmalloc(sizeof(int) * npes * 2);
for (i=0; i < _SHMEM_COLLECT_SYNC_SIZE; i++) {
pSync[i] = _SHMEM_SYNC_VALUE;
}
shmem_barrier_all(); /* Wait for all PEs to initialize pSync */
shmem_collect32(target, source, 2, 0, 0, npes, pSync);
printf("%d: %d", me, target[0]);
for (i = 1; i < npes * 2; i++)
printf(", %d", target[i]);
printf("\n");
return 0;
}
