void mpi_replyhandler(gasnet_token_t token, harg_t tid) { int ltid = tid - gasnet_mynode()*threads_num; PRINT_AM(("node=%2d> Got AMShort MPI Reply for tid=%d\n", (int)gasnet_mynode(), (int)tid)); assert(tt_thread_map[tid] == gasnet_mynode()); tt_thread_data[ltid].flag = 0; }
void mpi_handler(gasnet_token_t token, harg_t tid, harg_t sz) { gasnet_node_t node; int mpipeer; int tag; char *buf; gasnet_AMGetMsgSource(token, &node); PRINT_AM(("node=%2d> AMShort MPI Request for tid=%i, nbytes=%i\n", (int)gasnet_mynode(), (int)tid, (int)sz)); assert(tt_thread_map[tid] == node); assert(sz > 0); mpipeer = gasnetnode_to_mpirank[node]; tag = tid; buf = (char*)test_malloc(sz); MPI_LOCK(); assert(mpi_buf[tid] == NULL); assert(mpi_recvhandle[tid] == MPI_REQUEST_NULL); assert(mpi_sendhandle[tid] == MPI_REQUEST_NULL); mpi_buf[tid] = buf; mpi_bufsz[tid] = sz; ACTION_PRINTF("node=%2d> setting MPI_Irecv, %i bytes\n", (int)gasnet_mynode(), (int)sz); MPI_SAFE(MPI_Irecv(mpi_buf[tid], sz, MPI_BYTE, mpipeer, tag, MPI_COMM_WORLD, &(mpi_recvhandle[tid]))); assert(mpi_recvhandle[tid] != MPI_REQUEST_NULL); MPI_UNLOCK(); }
void pong_shorthandler(gasnet_token_t token, harg_t idx) { int tid = tt_thread_data[idx].tid; PRINT_AM(("node=%2d> AMShort Reply for tid=%d, (%d,%d)", (int)gasnet_mynode(), tid, (int)gasnet_mynode(), (int)idx)); assert(idx >= 0 && idx < threads_num); assert(tid >= 0 && tid < threads_num*gasnet_nodes()); tt_thread_data[idx].flag++; }
void pong_longhandler(gasnet_token_t token, void *buf, size_t nbytes, harg_t idx) { int tid = tt_thread_data[idx].tid; PRINT_AM(("node=%2d> AMLong Reply for tid=%d, (%d,%d)", (int)gasnet_mynode(), tid, (int)gasnet_mynode(), (int)idx)); assert(idx >= 0 && idx < threads_num); assert(tid >= 0 && tid < threads_num*gasnet_nodes()); assert(nbytes <= gasnet_AMMaxLongReply()); assert(buf == tt_addr_map[gasnet_mynode() * threads_num + idx]); assert((uintptr_t)buf + nbytes <= (uintptr_t)TEST_SEG(gasnet_mynode()) + TEST_SEGSZ); tt_thread_data[idx].flag++; }
void pong_medhandler(gasnet_token_t token, void *buf, size_t nbytes, gasnet_handlerarg_t idx) { int tid = tt_thread_data[idx].tid; PRINT_AM(("node=%2d> AMMedium Reply for tid=%d, (%d,%d)", (int)gasnet_mynode(), tid, (int)gasnet_mynode(), (int)idx)); assert(idx >= 0 && idx < threads_num); assert(tid >= 0 && tid < threads_num*gasnet_nodes()); assert(nbytes <= gasnet_AMMaxMedium()); assert((uintptr_t)buf+nbytes < (uintptr_t)TEST_SEG(gasnet_mynode()) || (uintptr_t)buf >= (uintptr_t)TEST_SEG(gasnet_mynode()) + TEST_SEGSZ); tt_thread_data[idx].flag++; }
int main(int argc, char **argv) { gasnet_node_t rank, size; size_t segsz = GASNET_PAGESIZE; size_t heapsz = GASNET_PAGESIZE; int argi; GASNET_SAFE(gasnet_init(&argc, &argv)); rank = gasnet_mynode(); size = gasnet_nodes(); argi = 1; if ((argi < argc) && !strcmp(argv[argi], "-m")) { segsz = gasnet_getMaxLocalSegmentSize(); ++argi; } GASNET_SAFE(gasnet_attach(NULL, 0, segsz, heapsz)); /* Only first and last print here, to keep managable I/O volume at scale */ if (!rank || (rank == size-1)) printf("Hello from node %d of %d\n", (int)rank, (int)size); /* Spec says client should include a barrier before gasnet_exit() */ gasnet_barrier_notify(0,GASNET_BARRIERFLAG_ANONYMOUS); gasnet_barrier_wait(0,GASNET_BARRIERFLAG_ANONYMOUS); gasnet_exit(0); /* Not reached in most implementations */ return 0; }
int gasnetc_AM_Generic(gasnetc_category_t category, int dest, gasnet_handler_t handler_id, void *src_addr, int nbytes, void *dst_addr, uint8_t is_request, uint8_t is_sync_request, uint8_t msg_num, int numargs, va_list argptr) { gasnet_mxm_send_req_t sreq; gasnet_mxm_send_req_t * p_sreq; mxm_send_req_t * mxm_sreq; int i, sge_idx = 0; /* * Encoding the following metadata in the immediate field: * - AM handler ID (1 byte) * - number of args (1 byte) * - message category (2 bits) * - whether the message is a request (1 bit) * - whether the message is a synchronous request (1 bit) * - message number (1 byte) */ mxm_imm_t imm_data = (mxm_imm_t) GASNETC_MSG_METADATA( handler_id, numargs, category, is_request, is_sync_request, SYSTEM_MSG_NA, msg_num); /* using source node ID as tag */ mxm_tag_t tag = (mxm_tag_t) gasnet_mynode(); if_pf (GASNETC_LONG_ASYNC_REQ(category, is_request, is_sync_request)) p_sreq = gasnetc_alloc_send_req(); else
void mpi_probehandler(gasnet_token_t token, harg_t tid) { gasnet_node_t node; int mpipeer; int tag; int reply = 0; gasnet_AMGetMsgSource(token, &node); assert(tt_thread_map[tid] == node); mpipeer = gasnetnode_to_mpirank[node]; tag = tid; MPI_LOCK(); if (mpi_recvhandle[tid] != MPI_REQUEST_NULL) { MPI_Status status; int flag = 0; MPI_SAFE(MPI_Test(&mpi_recvhandle[tid],&flag,&status)); if (flag) { int sz = mpi_bufsz[tid]; assert(mpi_recvhandle[tid] == MPI_REQUEST_NULL); assert(mpi_sendhandle[tid] == MPI_REQUEST_NULL); assert(mpi_buf[tid] != NULL && sz >= 0); ACTION_PRINTF("node=%2d> sending MPI reply message, %i bytes\n", (int)gasnet_mynode(), sz); MPI_SAFE(MPI_Isend(mpi_buf[tid], sz, MPI_BYTE, mpipeer, 10000+tag, MPI_COMM_WORLD, &(mpi_sendhandle[tid]))); assert(mpi_sendhandle[tid] != MPI_REQUEST_NULL); } } else if (mpi_sendhandle[tid] != MPI_REQUEST_NULL) { MPI_Status status; int flag = 0; MPI_SAFE(MPI_Test(&mpi_sendhandle[tid],&flag,&status)); if (flag) { assert(mpi_recvhandle[tid] == MPI_REQUEST_NULL); assert(mpi_sendhandle[tid] == MPI_REQUEST_NULL); reply = 1; } } else { /* nothing to do */ } MPI_UNLOCK(); if (reply) { assert(mpi_buf[tid] != NULL); test_free(mpi_buf[tid]); mpi_buf[tid] = NULL; PRINT_AM(("node=%2d> Sending AMShort MPI Reply for tid=%i\n", (int)gasnet_mynode(), (int)tid)); GASNET_Safe(gasnet_AMReplyShort1(token, hidx_mpi_replyhandler, tid)); } }
void ping_medhandler(gasnet_token_t token, void *buf, size_t nbytes, harg_t idx) { gasnet_node_t node; gasnet_AMGetMsgSource(token, &node); PRINT_AM(("node=%2d> AMMedium Request for (%d,%d)", (int)gasnet_mynode(), (int)node, (int)idx)); assert(idx >= 0 && idx < threads_num); assert(node < gasnet_nodes()); assert(nbytes <= gasnet_AMMaxMedium()); assert((uintptr_t)buf+nbytes < (uintptr_t)TEST_SEG(gasnet_mynode()) || (uintptr_t)buf >= (uintptr_t)TEST_SEG(gasnet_mynode()) + TEST_SEGSZ); GASNET_Safe( gasnet_AMReplyMedium1(token, hidx_pong_medhandler, buf, nbytes, idx)); }
extern void gasnetc_trace_finish(void) { /* dump AMUDP statistics */ if (GASNETI_STATS_ENABLED(C) ) { const char *statdump; int isglobal = 0; int retval = 0; amudp_stats_t stats = AMUDP_initial_stats; /* bug 2181 - lock state is unknown, eg we may be in handler context */ AMLOCK_CAUTIOUS(); if (isglobal) { /* TODO: tricky bit - if this exit is collective, we can display more interesting and useful statistics with collective cooperation. But there's no easy way to know for sure whether the exit is collective. */ /* TODO: want a bootstrap barrier here for global stats to ensure network is quiescent, but no way to do this unless we know things are collective */ if (gasnet_mynode() != 0) { GASNETI_AM_SAFE_NORETURN(retval, AMUDP_GetEndpointStatistics(gasnetc_endpoint, &stats)); /* get statistics */ /* TODO: send stats to zero */ } else { amudp_stats_t *remote_stats = NULL; /* TODO: gather stats from all nodes */ GASNETI_AM_SAFE_NORETURN(retval, AMUDP_AggregateStatistics(&stats, remote_stats)); } } else { GASNETI_AM_SAFE_NORETURN(retval, AMUDP_GetEndpointStatistics(gasnetc_endpoint, &stats)); /* get statistics */ } if ((gasnet_mynode() == 0 || !isglobal) && !retval) { GASNETI_STATS_PRINTF(C,("--------------------------------------------------------------------------------")); GASNETI_STATS_PRINTF(C,("AMUDP Statistics:")); if (!isglobal) GASNETI_STATS_PRINTF(C,("*** AMUDP stat dump reflects only local node info, because gasnet_exit is non-collective ***")); statdump = AMUDP_DumpStatistics(NULL, &stats, isglobal); GASNETI_STATS_PRINTF(C,("\n%s",statdump)); /* note, dump has embedded '%' chars */ GASNETI_STATS_PRINTF(C,("--------------------------------------------------------------------------------")); } } }
void grt_init(int argc, char **argv) { pthread_t thread; /* Set up handler table */ if (!entry_table) { entry_table = grt_entry_table; table_size = GRT_TABLE_SIZE; } /* call startup */ GASNET_Safe(gasnet_init(&argc, &argv)); /* get SPMD info */ grt_id = gasnet_mynode(); grt_num_procs = gasnet_nodes(); gethostname(grt_proc_name, MAX_PROCESSOR_NAME); /* Attach to network */ GASNET_Safe(gasnet_attach(entry_table, table_size, GASNET_HEAP_SIZE, MINHEAPOFFSET)); if (grt_id == 0) { printf("%s\n", argv[0]); #ifdef GRT_WORD_32 printf("We are on a 32-bit machine.\n"); #else printf("We are on a 64-bit machine.\n"); #endif printf("gasnet_AMMaxMedium()=%lu\n", gasnet_AMMaxMedium()); printf("gasnet_AMMaxLongRequest()=%lu\n", gasnet_AMMaxLongRequest()); printf("gasnet_AMMaxLongReply()=%lu\n", gasnet_AMMaxLongReply()); } fflush(stdout); BARRIER(); fflush(stdout); BARRIER(); /* Get segment info */ grt_seginfo = (gasnet_seginfo_t*) malloc(sizeof(gasnet_seginfo_t) * grt_num_procs); GASNET_Safe(gasnet_getSegmentInfo(grt_seginfo, grt_num_procs)); /* Initialize the heap for memory allocation */ grt_heap_base = grt_addr(grt_id, 0); grt_heap = umalloc_makeheap(grt_heap_base, grt_heap_size, UMALLOC_HEAP_GROWS_UP); /* Spawn off a thread to handle remote handler requests */ pthread_create(&thread, NULL, poll, NULL); /* Set up thread list */ linkedlist_init(&thread_list, 0, 0); BARRIER(); }
void gasnete_coll_tree_geom_print(gasnete_coll_tree_geom_t *geom) { uint32_t ref_count, local_ref_count; gasnet_node_t i; ref_count = gasneti_weakatomic_read(&(geom->ref_count), 0); fprintf(stderr, "[%u] tree_geom %p, ref_count %u.\n", gasnet_mynode(), geom, ref_count); for (i=0; i<gasnet_nodes(); i++) { if (geom->local_views[i] != NULL) { local_ref_count = gasneti_weakatomic_read(&(geom->local_views[i]->ref_count), 0); fprintf(stderr, "[%u] localview[%u] ref_count %u\n", gasnet_mynode(), i, local_ref_count); } } }
/* called by a single thread after gasnet_attach and args parsing */ void attach_test_mpi(void) { int rank; int gasnet_node; int mpinodes; int tot_threads; int i; MPI_SAFE(MPI_Barrier(MPI_COMM_WORLD)); /* setup gasnetnode <=> mpi rank mappings */ gasnetnode_to_mpirank = test_malloc(sizeof(int)*gasnet_nodes()); mpirank_to_gasnetnode = test_malloc(sizeof(int)*gasnet_nodes()); MPI_SAFE(MPI_Comm_rank(MPI_COMM_WORLD, &rank)); MPI_SAFE(MPI_Comm_size(MPI_COMM_WORLD, &mpinodes)); printf("GASNet node %i == MPI node %i\n", (int)gasnet_mynode(), rank); if (gasnet_mynode() != rank) printf("WARNING: Node numbering between GASNet and MPI do not coincide\n"); assert_always(mpinodes == gasnet_nodes() && rank >= 0 && rank < mpinodes); gasnet_node = gasnet_mynode(); MPI_SAFE(MPI_Allgather(&gasnet_node,sizeof(int),MPI_BYTE, mpirank_to_gasnetnode,sizeof(int),MPI_BYTE, MPI_COMM_WORLD)); assert_always(mpirank_to_gasnetnode[rank] == gasnet_mynode()); for (i = 0; i < mpinodes; i++) gasnetnode_to_mpirank[i] = -1; for (i = 0; i < mpinodes; i++) gasnetnode_to_mpirank[mpirank_to_gasnetnode[i]] = i; for (i = 0; i < mpinodes; i++) assert_always(gasnetnode_to_mpirank[i] != -1); tot_threads = threads_num * gasnet_nodes(); mpi_recvhandle = test_malloc(sizeof(MPI_Request)*tot_threads); mpi_sendhandle = test_malloc(sizeof(MPI_Request)*tot_threads); mpi_buf = test_malloc(sizeof(char *)*tot_threads); mpi_bufsz = test_malloc(sizeof(int)*tot_threads); for (i = 0; i < tot_threads; i++) { mpi_recvhandle[i] = MPI_REQUEST_NULL; mpi_sendhandle[i] = MPI_REQUEST_NULL; mpi_buf[i] = NULL; mpi_bufsz[i] = 0; } MPI_SAFE(MPI_Barrier(MPI_COMM_WORLD)); }
void ping_shorthandler(gasnet_token_t token, harg_t idx) { gasnet_node_t node; gasnet_AMGetMsgSource(token, &node); PRINT_AM(("node=%2d> AMShort Request for (%d,%d)", (int)gasnet_mynode(), (int)node, (int)idx)); assert(idx >= 0 && idx < threads_num); assert(node < gasnet_nodes()); GASNET_Safe(gasnet_AMReplyShort1(token, hidx_pong_shorthandler, idx)); }
void ping_longhandler(gasnet_token_t token, void *buf, size_t nbytes, harg_t idx, harg_t target_id) { int tid; void *paddr; gasnet_node_t node; gasnet_AMGetMsgSource(token, &node); tid = node * threads_num + idx; paddr = tt_addr_map[tid]; PRINT_AM(("node=%2d> AMLong Request for (%d,%d)", (int)gasnet_mynode(), (int)node, (int)idx)); assert(idx >= 0 && idx < threads_num); assert(node < gasnet_nodes()); assert(nbytes <= gasnet_AMMaxLongRequest()); assert(buf == tt_addr_map[target_id]); assert((uintptr_t)buf + nbytes <= (uintptr_t)TEST_SEG(gasnet_mynode()) + TEST_SEGSZ); GASNET_Safe( gasnet_AMReplyLong1(token, hidx_pong_longhandler, buf, nbytes, paddr, idx)); }
uint32_t gasnetc_find_lkey(void *src_addr, int nbytes) { #if GASNET_SEGMENT_FAST gasnetc_memreg_t * reg; if (nbytes < gasnet_mxm_module.zcopy_thresh) return NULL; reg = gasnetc_find_reg(src_addr, nbytes, gasnet_mynode()); return (reg) ? reg->lkey : MXM_MKEY_NONE; #else return MXM_MKEY_NONE; #endif }
mxm_mem_h gasnetc_find_memh(void *addr, int nbytes) { #if GASNET_SEGMENT_FAST gasnetc_memreg_t * reg; if (nbytes < gasnet_mxm_module.zcopy_thresh) return NULL; reg = gasnetc_find_reg(addr, nbytes, gasnet_mynode()); return (reg) ? reg->memh : NULL; #else return NULL; #endif }
void alloc_thread_data(int threads) { int nodes, tot_threads; nodes = gasnet_nodes(); tot_threads = nodes * threads; tt_thread_map = (gasnet_node_t *) test_malloc(sizeof(gasnet_node_t) * tot_threads); tt_thread_data = (threaddata_t *) test_malloc(sizeof(threaddata_t) * threads); tt_addr_map = (void **) test_malloc(sizeof(void *) * tot_threads); /* Initialize the thread to node map array and local thread data */ { int i, j, tid, base; void *segbase; threaddata_t *td; for (i = 0; i < nodes; i++) { segbase = TEST_SEG(i); base = i * threads; for (j = 0; j < threads; j++) { tid = base + j; tt_thread_map[tid] = i; tt_addr_map[tid] = (void *) ((uintptr_t) segbase + (uintptr_t) (j * TEST_SEGZ_PER_THREAD)); if (i == gasnet_mynode()) { td = &tt_thread_data[j]; td->tid = tid; td->ltid = j; td->tid_peer_local = base + ((j+1) % threads); td->tid_peer = (tid+threads) % tot_threads; } } } } }
int main(int argc, char **argv) { int iters = 0; gasnet_handlerentry_t htable[] = { { 201, chksum_reqh }, { 202, chksum_reph } }; /* call startup */ GASNET_Safe(gasnet_init(&argc, &argv)); GASNET_Safe(gasnet_attach(htable, sizeof(htable)/sizeof(gasnet_handlerentry_t), TEST_SEGSZ_REQUEST, TEST_MINHEAPOFFSET)); test_init("testcore1",0,"(iters)"); assert(CHKSUM_TOTAL <= gasnet_AMMaxMedium()); if (argc > 1) iters = atoi(argv[1]); if (!iters) iters = 1000; if (argc > 2) test_usage(); /* get SPMD info */ chksum_iters = iters; myproc = gasnet_mynode(); numprocs = gasnet_nodes(); /* Only allow even number for numprocs */ if (numprocs % 2 != 0) { MSG("WARNING: This test requires an even number of nodes. Test skipped.\n"); gasnet_exit(0); /* exit 0 to prevent false negatives in test harnesses for smp-conduit */ } peerproc = (myproc % 2) ? myproc-1 : myproc+1; seginfo_table = (gasnet_seginfo_t *) test_malloc(sizeof(gasnet_seginfo_t) * numprocs); printf("%d> starting monoseed_init(%d)\n", myproc, iters); monoseed_init(iters); printf("%d> starting chksums_test(%d)\n", myproc, iters); chksum_test(iters); gasnet_exit(0); return(0); }
/* This tester measures the performance of a number of miscellaneous GASNet functions that don't involve actual communication, to assist in evaluating the overhead of the GASNet layer itself */ int main(int argc, char **argv) { gasnet_handlerentry_t htable[] = { { hidx_null_shorthandler, null_shorthandler }, { hidx_justreply_shorthandler, justreply_shorthandler }, { hidx_null_medhandler, null_medhandler }, { hidx_justreply_medhandler, justreply_medhandler }, { hidx_null_longhandler, null_longhandler }, { hidx_justreply_longhandler, justreply_longhandler } }; GASNET_Safe(gasnet_init(&argc, &argv)); GASNET_Safe(gasnet_attach(htable, sizeof(htable)/sizeof(gasnet_handlerentry_t), TEST_SEGSZ_REQUEST, TEST_MINHEAPOFFSET)); test_init("testmisc",1,"(iters) (accuracy_digits) (test_sections)"); mynode = gasnet_mynode(); myseg = TEST_MYSEG(); if (argc > 1) iters = atoi(argv[1]); if (!iters) iters = 100000; if (argc > 2) accuracy = atoi(argv[2]); if (!accuracy) accuracy = 3; if (argc > 3) TEST_SECTION_PARSE(argv[3]); if (argc > 4) test_usage(); if (mynode == 0) { printf("Running misc performance test with %i iterations...\n",iters); printf("%-50s Total time Avg. time\n" "%-50s ---------- ---------\n", "", ""); fflush(stdout); } doit1(); MSG("done."); gasnet_exit(0); return 0; }
int main(int argc, char **argv) { int i,j; static uint8_t *A, *B; thread_data_t *td_arr; GASNET_Safe(gasnet_init(&argc, &argv)); performance_iters = DEFAULT_PERFORMANCE_ITERS; for(i=1; i<argc; i++) { if(strcmp("-i", argv[i])==0 || strcmp("-iters", argv[i])==0) { performance_iters = atoi(argv[i+1]); i++; } else if(strcmp("-f", argv[i])==0 || strcmp("-tune-file", argv[i])==0) { outputfile = test_malloc(strlen(argv[i+1])+1); strcpy(outputfile, argv[i+1]); i++; } else if(strcmp("-p", argv[i])==0 || strcmp("-profile", argv[i])==0) { profile_file = test_malloc(strlen(argv[i+1])+1); strcpy(profile_file, argv[i+1]); i++; } else if(strcmp("-h", argv[i])==0 || strcmp("-help", argv[i])==0) { MSG0("usage: %s (-i iters) (-f output file)\n", argv[0]); gasnet_exit(0); } } max_data_size = 0; threads_per_node = 0; profile_info = load_file(profile_file); fill_meta_data(profile_info); printf("data loaded: %d %d\n", (int)max_data_size, threads_per_node); if(max_data_size <=0) { fprintf(stderr, "max data size(%d) should be >=0\n", (int) max_data_size); gasnet_exit(1); } if(threads_per_node<1) { fprintf(stderr, "threads_per_node (%d) should be > 0\n", threads_per_node); gasnet_exit(1); } if(performance_iters <=0) { gasnet_exit(0); } mynode = gasnet_mynode(); nodes = gasnet_nodes(); THREADS = nodes * threads_per_node; GASNET_Safe(gasnet_attach(NULL, 0, TEST_SEGSZ_REQUEST, TEST_MINHEAPOFFSET)); /* ?? test_init("testcolltuner",0,"(-i iters) (-f output_file)"); */ A = TEST_MYSEG(); B = A+(SEG_PER_THREAD*threads_per_node); my_srcs = (uint8_t**) test_malloc(sizeof(uint8_t*)*threads_per_node); my_dsts = (uint8_t**) test_malloc(sizeof(uint8_t*)*threads_per_node); all_srcs = (uint8_t**) test_malloc(sizeof(uint8_t*)*THREADS); all_dsts = (uint8_t**) test_malloc(sizeof(uint8_t*)*THREADS); td_arr = (thread_data_t*) test_malloc(sizeof(thread_data_t)*threads_per_node); TEST_SET_WAITMODE(threads_per_node); for(i=0; i<threads_per_node; i++) { my_srcs[i] = A + i*SEG_PER_THREAD; my_dsts[i] = B + i*SEG_PER_THREAD; td_arr[i].my_local_thread = i; td_arr[i].mythread = mynode*threads_per_node+i; td_arr[i].mysrc = my_srcs[i]; td_arr[i].mydest = my_dsts[i]; } for(i=0; i<nodes; i++) { /* assert_always(TEST_SEG(i).size >= SEG_PER_THREAD*threads_per_node); */ for(j=0; j<threads_per_node; j++) { all_srcs[i*threads_per_node+j] = (uint8_t*) TEST_SEG(i) + j*SEG_PER_THREAD; all_dsts[i*threads_per_node+j] = (uint8_t*) TEST_SEG(i) + SEG_PER_THREAD*threads_per_node + j*SEG_PER_THREAD; } } #if GASNET_PAR test_createandjoin_pthreads(threads_per_node, &thread_main, td_arr, sizeof(thread_data_t)); #else thread_main(&td_arr[0]); #endif test_free(td_arr); BARRIER(); gasnet_exit(0); return 0; }
int main(int argc, char **argv) { int help=0; int arg=1; gasnet_handlerentry_t htable[] = { { hidx_ping_shorthandler, ping_shorthandler }, { hidx_pong_shorthandler, pong_shorthandler }, { hidx_ping_medhandler, ping_medhandler }, { hidx_pong_medhandler, pong_medhandler }, { hidx_ping_longhandler, ping_longhandler }, { hidx_pong_longhandler, pong_longhandler }, { hidx_ping_shorthandler_flood, ping_shorthandler_flood }, { hidx_pong_shorthandler_flood, pong_shorthandler_flood }, { hidx_ping_medhandler_flood, ping_medhandler_flood }, { hidx_pong_medhandler_flood, pong_medhandler_flood }, { hidx_ping_longhandler_flood, ping_longhandler_flood }, { hidx_pong_longhandler_flood, pong_longhandler_flood }, { hidx_done_shorthandler, done_shorthandler } }; GASNET_Safe(gasnet_init(&argc, &argv)); mynode = gasnet_mynode(); numnode = gasnet_nodes(); arg = 1; while (argc > arg) { if (!strcmp(argv[arg], "-p")) { #if GASNET_PAR pollers = test_thread_limit(atoi(argv[arg+1])+1)-1; arg += 2; #else if (0 == mynode) { fprintf(stderr, "testam %s\n", GASNET_CONFIG_STRING); fprintf(stderr, "ERROR: The -p option is only available in the PAR configuration.\n"); fflush(NULL); } sleep(1); gasnet_exit(1); #endif } else if (!strcmp(argv[arg], "-in")) { insegment = 1; ++arg; } else if (!strcmp(argv[arg], "-out")) { insegment = 0; ++arg; } else if (!strcmp(argv[arg], "-c")) { crossmachinemode = 1; ++arg; } else if (!strcmp(argv[arg], "-src-noop")) { src_mode = SRC_NOOP; ++arg; } else if (!strcmp(argv[arg], "-src-generate")) { src_mode = SRC_GENERATE; ++arg; } else if (!strcmp(argv[arg], "-src-memcpy")) { src_mode = SRC_MEMCPY; ++arg; } else if (argv[arg][0] == '-') { help = 1; ++arg; } else break; } if (argc > arg) { iters = atoi(argv[arg]); ++arg; } if (!iters) iters = 1000; if (argc > arg) { maxsz = atoi(argv[arg]); ++arg; } if (!maxsz) maxsz = 2*1024*1024; if (argc > arg) { TEST_SECTION_PARSE(argv[arg]); ++arg; } GASNET_Safe(gasnet_attach(htable, sizeof(htable)/sizeof(gasnet_handlerentry_t), TEST_SEGSZ_REQUEST, TEST_MINHEAPOFFSET)); #if GASNET_PAR #define PAR_USAGE \ " The -p option gives the number of polling threads, specified as\n" \ " a non-negative integer argument (default is no polling threads).\n" #else #define PAR_USAGE "" #endif test_init("testam", 1, "[options] (iters) (maxsz) (test_sections)\n" " The '-in' or '-out' option selects whether the requestor's\n" " buffer is in the GASNet segment or not (default is 'in').\n" PAR_USAGE " The '-src-*' options select treatment of the payload buffer used for\n" " Medium and Long AMs, as follows:\n" " -src-noop: no per-operation initialization (default)\n" " -src-generate: initialized (w/o memory reads) on each AM injection\n" " -src-memcpy: initialized using memcpy() on each AM injection\n" " The -c option enables cross-machine pairing (default is nearest neighbor).\n"); if (help || argc > arg) test_usage(); TEST_PRINT_CONDUITINFO(); if (insegment) { myseg = TEST_MYSEG(); } else { char *space = test_malloc(alignup(maxsz,PAGESZ) + PAGESZ); myseg = alignup_ptr(space, PAGESZ); } maxmed = MIN(maxsz, gasnet_AMMaxMedium()); maxlongreq = MIN(maxsz, gasnet_AMMaxLongRequest()); maxlongrep = MIN(maxsz, gasnet_AMMaxLongReply()); if (src_mode == SRC_MEMCPY) { zero_buffer = test_calloc(maxsz, 1); } if (crossmachinemode) { if ((numnode%2) && (mynode == numnode-1)) { sender = 1; peer = mynode; } else { gasnet_node_t half = numnode / 2; sender = (mynode < half); peer = sender ? (mynode + half) : (mynode - half); } } else { peer = mynode ^ 1; sender = mynode % 2 == 0; if (peer == numnode) { peer = mynode; } } recvr = !sender || (peer == mynode); // Long Request and Reply (distinct for loopback) reply_addr = TEST_SEG(peer); request_addr = (peer == mynode) ? (void*)((uintptr_t)reply_addr + alignup(maxsz,SIZEOF_GASNET_REGISTER_VALUE_T)) : reply_addr; BARRIER(); #if GASNET_PAR #define PAR_FMT " %i extra recvr polling threads\n" #define PAR_ARG ,pollers #else #define PAR_FMT /*empty*/ #define PAR_ARG /*empty*/ #endif if (mynode == 0) { printf("Running %i iterations of %s AM performance with:\n" " local addresses %sside the segment%s\n" " %s\n" PAR_FMT " ...\n", iters, (crossmachinemode ? "cross-machine ": ""), (insegment ? "in" : "out"), (insegment ? " (default)" : ""), ((src_mode == SRC_NOOP) ? "no payload initialization (default)" :(src_mode == SRC_GENERATE) ? "payload initialized by computation" : "payload initialized using memcpy()") PAR_ARG ); printf(" Msg Sz Description Total time Avg. time Bandwidth\n" " ------ ----------- ---------- --------- ---------\n"); fflush(stdout); } #if GASNET_PAR TEST_SET_WAITMODE(pollers+1); if (pollers) test_createandjoin_pthreads(pollers+1,doAll,NULL,0); else #endif doAll(NULL); MSG("done."); gasnet_exit(0); return 0; }
int main(int argc, char **argv) { const char *kind = ""; int pollers = 0; int arg = 1; GASNET_Safe(gasnet_init(&argc, &argv)); GASNET_Safe(gasnet_attach(htable, 1, TEST_SEGSZ_REQUEST, TEST_MINHEAPOFFSET)); TEST_COLL_INIT(); #if GASNET_PAR test_init("testbarrier", 1, "[-t] [-p polling_threads] (iters)\n" " The -p option gives a number of polling threads to spawn (default is 0).\n" " The -b option replaces barrier_notify calls with blocking barrier calls\n" " The -t option replaces barrier_wait calls with looping on barrier_try"); #else test_init("testbarrier", 1, "[-t] (iters)\n" " The -b option replaces barrier_notify calls with blocking barrier calls\n" " The -t option replaces barrier_wait calls with looping on barrier_try"); #endif mynode = gasnet_mynode(); nodes = gasnet_nodes(); while (argc-arg >= 2) { if (!strcmp(argv[arg], "-p")) { #if GASNET_PAR pollers = test_thread_limit(atoi(argv[arg+1])+1)-1; arg += 2; #else if (gasnet_mynode() == 0) { fprintf(stderr, "testbarrier %s\n", GASNET_CONFIG_STRING); fprintf(stderr, "ERROR: The -p option is only available in the PAR configuration.\n"); fflush(NULL); } sleep(1); gasnet_exit(1); #endif } else if (!strcmp(argv[arg], "-t")) { do_try = 1; kind = " polling"; arg += 1; } else if (!strcmp(argv[arg], "-b")) { do_block = 1; kind = " blocking"; arg += 1; } } if (argc-arg >= 1) iters = atoi(argv[arg]); if (!iters) iters = 10000; if (argc-arg >= 2) test_usage(); if (do_try && do_block) { if (!mynode) fprintf(stderr, "ERROR: The -b and -t options are mutually exclusive.\n"); gasnet_exit(1); } #if !defined(GASNET_PAR) MSG0("Running%s barrier test with %i iterations...\n",kind,iters); #else MSG0("Running%s barrier test with %i iterations and %i extra polling threads...\n",kind,iters,pollers); TEST_SET_WAITMODE(pollers+1); if (pollers) test_createandjoin_pthreads(pollers+1,doTest,NULL,0); else #endif doTest(NULL); BARRIER(); MSG("done."); gasnet_exit(0); return 0; }
int main(int argc, char **argv) { int mynode, nodes, iters=0; int64_t start,total; int i = 0; gasnet_node_t nrows, ncols, my_row, my_col; void *clientdata = NULL; gasnet_team_handle_t my_row_team, my_col_team; static uint8_t *A, *B; gasnet_seginfo_t teamA_scratch; gasnet_seginfo_t teamB_scratch; gasnet_seginfo_t const * test_segs; GASNET_Safe(gasnet_init(&argc, &argv)); GASNET_Safe(gasnet_attach(NULL, 0, TEST_SEGSZ_REQUEST, TEST_MINHEAPOFFSET)); #if !GASNET_SEQ MSG0("WARNING: This test does not work for NON-SEQ builds yet.. skipping test\n"); gasnet_exit(0); #endif A = TEST_MYSEG(); gasnet_coll_init(NULL, 0, NULL, 0, 0); test_init("testteam", 1, "(iters) (nrows) (ncols)"); mynode = gasnet_mynode(); nodes = gasnet_nodes(); test_segs = TEST_SEGINFO(); teamA_scratch.addr = test_segs[mynode].addr; teamA_scratch.size = test_segs[mynode].size/2; teamB_scratch.addr = (uint8_t*)teamA_scratch.addr + teamA_scratch.size; teamB_scratch.size = teamA_scratch.size; if (argc > 4) test_usage(); if (argc > 1) iters = atoi(argv[1]); if (!iters) iters = 10000; if (argc > 2) { nrows = atoi(argv[2]); } else { /* search for as near to square as possible */ nrows = sqrt(nodes); while (nodes % nrows) --nrows; } if (argc > 3) { ncols = atoi(argv[3]); } else { ncols = nodes / nrows; } assert_always(nrows*ncols == nodes); MSG0("Running team test with a %u-by-%u grid and %i iterations...\n", (int)nrows, (int)ncols, iters); BARRIER(); my_row = mynode / ncols; my_col = mynode % ncols; my_row_team = gasnet_coll_team_split(GASNET_TEAM_ALL, my_row, my_col, &teamA_scratch); my_col_team = gasnet_coll_team_split(GASNET_TEAM_ALL, my_col, my_row, &teamB_scratch); if (my_col == 0) { printf("row team %u: Running team barrier test with row teams...\n", (int)my_row); fflush(stdout); } BARRIER(); start = TIME(); for (i=0; i < iters; i++) { gasnete_coll_teambarrier_notify(my_row_team); gasnete_coll_teambarrier_wait(my_row_team); } total = TIME() - start; if (my_col == 0) { printf("row team %u: total time: %8.3f sec, avg row team Barrier latency: %8.3f us\n", (int)my_row, ((float)total)/1000000, ((float)total)/iters); fflush(stdout); } if (my_row == 0) { printf("col team %u: Running team barrier test with column teams...\n", (int)my_col); fflush(stdout); } BARRIER(); start = TIME(); for (i=0; i < iters; i++) { gasnete_coll_teambarrier_notify(my_col_team); gasnete_coll_teambarrier_wait(my_col_team); } total = TIME() - start; if (my_row == 0) { printf("col team %u: total time: %8.3f sec Avg column team Barrier latency: %8.3f us\n", (int)my_col, ((float)total)/1000000, ((float)total)/iters); fflush(stdout); } BARRIER(); MSG("done."); gasnet_exit(0); /* for faster exit */ return 0; }
int main(int argc, char **argv) { int arg = 1, help = 0; gasnet_handlerentry_t htable[] = { { hidx_ping_medhandler, ping_medhandler }, { hidx_pong_medhandler, pong_medhandler }, { hidx_ping_longhandler, ping_longhandler }, { hidx_pong_longhandler, pong_longhandler }, { hidx_ping_alonghandler, ping_alonghandler }, }; /* call startup */ GASNET_Safe(gasnet_init(&argc, &argv)); #define AMOPT() if (!amopt) { amopt = 1; domed = 0; dolong = 0; dolongasync = 0; } while (argc > arg) { if (!strcmp(argv[arg], "-p")) { doprime = 1; ++arg; } else if (!strcmp(argv[arg], "-u")) { dosizesync = 0; ++arg; } else if (!strcmp(argv[arg], "-s")) { domultith = 0; ++arg; } else if (!strcmp(argv[arg], "-n")) { allowretry = 0; ++arg; } else if (!strcmp(argv[arg], "-in")) { doinseg = 1; dooutseg = 0; ++arg; } else if (!strcmp(argv[arg], "-out")) { doinseg = 0; dooutseg = 1; ++arg; } else if (!strcmp(argv[arg], "-m")) { AMOPT(); domed = 1; ++arg; } else if (!strcmp(argv[arg], "-l")) { AMOPT(); dolong = 1; ++arg; } else if (!strcmp(argv[arg], "-a")) { AMOPT(); dolongasync = 1; ++arg; } else if (argv[arg][0] == '-') { help = 1; ++arg; } else break; } if (argc > arg) { iters = atoi(argv[arg]); arg++; } if (!iters) iters = 10; if (argc > arg) { max_payload = atoi(argv[arg]); arg++; } if (!max_payload) max_payload = 1024*1024; if (argc > arg) { depth = atoi(argv[arg]); arg++; } if (!depth) depth = 16; /* round down to largest payload AM allows */ maxlong = MIN(gasnet_AMMaxLongRequest(),gasnet_AMMaxLongReply()); max_payload = MIN(max_payload,MAX(gasnet_AMMaxMedium(),maxlong)); GASNET_Safe(gasnet_attach(htable, sizeof(htable)/sizeof(gasnet_handlerentry_t), TEST_SEGSZ_REQUEST, TEST_MINHEAPOFFSET)); test_init("testcore2",0,"[options] (iters) (max_payload) (depth)\n" " -m test AMMedium (defaults to all types)\n" " -l test AMLong (defaults to all types)\n" " -a test AMLongAsync (defaults to all types)\n" " -p prime the AMLong transfer areas with puts, to encourage pinning\n" " -u loosen sychronization to allow diff payload sizes to be in flight at once\n" " -s single-threaded PAR mode (default is to start a polling thread in PAR mode)\n" " -n no retry on failure\n" " -in/-out use only in- or out-of-segment sources for AMLong(Async) (default is both)\n" ); if (help || argc > arg) test_usage(); TEST_PRINT_CONDUITINFO(); /* get SPMD info */ myproc = gasnet_mynode(); numprocs = gasnet_nodes(); peerproc = myproc ^ 1; if (peerproc == gasnet_nodes()) { /* w/ odd # of nodes, last one talks to self */ peerproc = myproc; } myseg = TEST_MYSEG(); peerreqseg = TEST_SEG(peerproc); peerrepseg = peerreqseg+max_payload*depth*2; localseg = myseg + max_payload*depth*4; assert_always(TEST_SEGSZ >= max_payload*depth*5); privateseg = test_malloc(max_payload*depth*3); /* out-of-seg request src, long reply src, along reply src */ longreplysrc = privateseg+max_payload*depth; alongreplysrc = privateseg+max_payload*depth*2; #ifdef GASNET_PAR if (domultith) test_createandjoin_pthreads(2,doit,NULL,0); else #endif doit(0); BARRIER(); test_free(privateseg); MSG("done. (detected %i errs)", test_errs); gasnet_exit(test_errs > 0 ? 1 : 0); return 0; }
int main(int argc, char **argv) { static int *A, *B, *C, *D, *E, *F, *G; gasnet_node_t myproc, i; int j; /* call startup */ GASNET_Safe(gasnet_init(&argc, &argv)); if (argc > 1) { iters = atoi(argv[1]); } if (iters < 1) { iters = 1000; } #if GASNET_PAR if (argc > 2) { threads = atoi(argv[2]); } threads = test_thread_limit(threads); if (threads < 1) { printf("ERROR: Threads must be between 1 and %d\n", TEST_MAXTHREADS); exit(EXIT_FAILURE); } #endif /* get SPMD info */ myproc = gasnet_mynode(); numprocs = gasnet_nodes(); images = numprocs * threads; datasize = iters * (3 + 4 * images); GASNET_Safe(gasnet_attach(NULL, 0, TEST_SEGSZ_REQUEST, TEST_MINHEAPOFFSET)); test_init("testcoll",0,"(iters) (threadcnt)"); TEST_SET_WAITMODE(threads); if (argc > 3) test_usage(); MSG0("Running coll test(s) with %d iterations.", iters); R = test_malloc(iters*sizeof(int)); TEST_SRAND(1); /* Number if ints to store */ /* Carve some variables out of the (aligned) segment: */ Aw = test_malloc(iters * sizeof(int *)); Bw = test_malloc(iters * sizeof(int *)); Cw = test_malloc(iters * sizeof(int *)); Dw = test_malloc(iters * sizeof(int *)); Ew = test_malloc(iters * sizeof(int *)); Fw = test_malloc(iters * sizeof(int *)); Gw = test_malloc(iters * sizeof(int *)); A = (int *)TEST_MYSEG(); /* int [1*iters] */ B = A + 1*iters; /* int [1*iters] */ C = B + 1*iters; /* int [N*iters] */ D = C + images*iters; /* int [N*iters] */ E = D + images*iters; /* int [1*iters] */ F = E + 1*iters; /* int [N*iters] */ G = F + images*iters; /* int [N*iters] */ for (j = 0; j < iters; ++j) { Aw[j] = A + j; Bw[j] = B + j; Cw[j] = C + j*images; Dw[j] = D + j*images; Ew[j] = E + j; Fw[j] = F + j*images; Gw[j] = G + j*images; } /* The unaligned equivalents */ Av = test_malloc_2D(iters, images * sizeof(int *)); Bv = test_malloc_2D(iters, images * sizeof(int *)); Cv = test_malloc_2D(iters, images * sizeof(int *)); Dv = test_malloc_2D(iters, images * sizeof(int *)); Ev = test_malloc_2D(iters, images * sizeof(int *)); Fv = test_malloc_2D(iters, images * sizeof(int *)); Gv = test_malloc_2D(iters, images * sizeof(int *)); for (i = 0; i < images; ++i) { /* Using (TEST_SEG(n) + n) yields unaligned even when the segments are aligned. This is to help catch any case where addresses might have been misused that might go undetected if the addresses were aligned */ A = (int *)TEST_SEG(i/threads) + (i/threads) + datasize*(i%threads); B = A + 1*iters; C = B + 1*iters; D = C + images*iters; E = D + images*iters; F = E + 1*iters; G = F + images*iters; for (j = 0; j < iters; ++j) { Av[j][i] = A + j; Bv[j][i] = B + j; Cv[j][i] = C + j*images; Dv[j][i] = D + j*images; Ev[j][i] = E + j; Fv[j][i] = F + j*images; Gv[j][i] = G + j*images; } } BARRIER(); #if GASNET_PAR MSG("Forking %d gasnet threads", threads); { int i; thread_data_t* tt_thread_data = test_malloc(threads*sizeof(thread_data_t)); for (i = 0; i < threads; i++) { tt_thread_data[i].myproc = myproc; tt_thread_data[i].local_id = i; tt_thread_data[i].mythread = i + threads * myproc; tt_thread_data[i].peerthread = i + threads * (((myproc ^ 1) == numprocs) ? myproc : (myproc ^ 1)); } test_createandjoin_pthreads(threads, &thread_main, tt_thread_data, sizeof(tt_thread_data[0])); test_free(tt_thread_data); } #else { thread_data_t td; td.myproc = myproc; td.local_id = 0; td.mythread = myproc; td.peerthread = ((myproc ^ 1) == numprocs) ? myproc : (myproc ^ 1); thread_main(&td); } #endif BARRIER(); test_free(Aw); test_free(Bw); test_free(Cw); test_free(Dw); test_free_2D(Av); test_free_2D(Bv); test_free_2D(Cv); test_free_2D(Dv); test_free(R); MSG("done."); gasnet_exit(0); return 0; }
int main(int argc, char **argv) { static int *A, *B, *C, *D, *E, *F, *G; gasnet_node_t myproc, i; int pollers = 0; int j; /* call startup */ GASNET_Safe(gasnet_init(&argc, &argv)); int arg = 1; int help = 0; while (argc > arg) { if (!strcmp(argv[arg], "-p")) { #if GASNET_PAR ++arg; if (argc > arg) { pollers = atoi(argv[arg]); arg++; } else help = 1; #else if (0 == gasnet_mynode()) { fprintf(stderr, "testcoll %s\n", GASNET_CONFIG_STRING); fprintf(stderr, "ERROR: The -p option is only available in the PAR configuration.\n"); fflush(NULL); } sleep(1); gasnet_exit(1); #endif } else if (argv[arg][0] == '-') { help = 1; ++arg; } else break; } if (argc > arg) { iters = atoi(argv[arg]); ++arg; } if (iters < 1) { iters = 1000; } #if GASNET_PAR if (argc > arg) { threads = atoi(argv[arg]); ++arg; } threads = test_thread_limit(threads); if (threads < 1) { printf("ERROR: Threads must be between 1 and %d\n", TEST_MAXTHREADS); exit(EXIT_FAILURE); } #endif /* get SPMD info */ myproc = gasnet_mynode(); numprocs = gasnet_nodes(); images = numprocs * threads; datasize = iters * (3 + 4 * images); GASNET_Safe(gasnet_attach(NULL, 0, TEST_SEGSZ_REQUEST, TEST_MINHEAPOFFSET)); #if GASNET_PAR #define USAGE "[options] (iters) (threadcnt)\n" \ " The -p option gives the number of polling threads, specified as\n" \ " a non-negative integer argument (default is no polling threads).\n" #else #define USAGE "(iters)\n" #endif test_init("testcoll",0,USAGE); TEST_SET_WAITMODE(threads + pollers); if (argc > arg || help) test_usage(); MSG0("Running coll test(s) with %d iterations.", iters); R = test_malloc(iters*sizeof(int)); /* Number if ints to store */ /* Carve some variables out of the (aligned) segment: */ Aw = test_malloc(iters * sizeof(int *)); Bw = test_malloc(iters * sizeof(int *)); Cw = test_malloc(iters * sizeof(int *)); Dw = test_malloc(iters * sizeof(int *)); Ew = test_malloc(iters * sizeof(int *)); Fw = test_malloc(iters * sizeof(int *)); Gw = test_malloc(iters * sizeof(int *)); A = (int *)TEST_MYSEG(); /* int [1*iters] */ B = A + 1*iters; /* int [1*iters] */ C = B + 1*iters; /* int [N*iters] */ D = C + images*iters; /* int [N*iters] */ E = D + images*iters; /* int [1*iters] */ F = E + 1*iters; /* int [N*iters] */ G = F + images*iters; /* int [N*iters] */ for (j = 0; j < iters; ++j) { Aw[j] = A + j; Bw[j] = B + j; Cw[j] = C + j*images; Dw[j] = D + j*images; Ew[j] = E + j; Fw[j] = F + j*images; Gw[j] = G + j*images; } /* The unaligned equivalents */ Av = test_malloc_2D(iters, images * sizeof(int *)); Bv = test_malloc_2D(iters, images * sizeof(int *)); Cv = test_malloc_2D(iters, images * sizeof(int *)); Dv = test_malloc_2D(iters, images * sizeof(int *)); Ev = test_malloc_2D(iters, images * sizeof(int *)); Fv = test_malloc_2D(iters, images * sizeof(int *)); Gv = test_malloc_2D(iters, images * sizeof(int *)); for (i = 0; i < images; ++i) { /* Using (TEST_SEG(n) + n) yields unaligned even when the segments are aligned. This is to help catch any case where addresses might have been misused that might go undetected if the addresses were aligned */ A = (int *)TEST_SEG(i/threads) + (i/threads) + datasize*(i%threads); B = A + 1*iters; C = B + 1*iters; D = C + images*iters; E = D + images*iters; F = E + 1*iters; G = F + images*iters; for (j = 0; j < iters; ++j) { Av[j][i] = A + j; Bv[j][i] = B + j; Cv[j][i] = C + j*images; Dv[j][i] = D + j*images; Ev[j][i] = E + j; Fv[j][i] = F + j*images; Gv[j][i] = G + j*images; } } BARRIER(); #if GASNET_PAR MSG("Forking %d gasnet threads (%d active, %d polling)", threads+pollers, threads, pollers); { int i; thread_data_t* tt_thread_data = test_malloc(threads*sizeof(thread_data_t)); for (i = 0; i < threads; i++) { tt_thread_data[i].myproc = myproc; tt_thread_data[i].local_id = i; tt_thread_data[i].mythread = i + threads * myproc; tt_thread_data[i].peerthread = i + threads * (((myproc ^ 1) == numprocs) ? myproc : (myproc ^ 1)); } test_createandjoin_pthreads(threads, &thread_main, tt_thread_data, sizeof(tt_thread_data[0])); test_free(tt_thread_data); } #else { thread_data_t td; td.myproc = myproc; td.local_id = 0; td.mythread = myproc; td.peerthread = ((myproc ^ 1) == numprocs) ? myproc : (myproc ^ 1); thread_main(&td); } #endif BARRIER(); test_free(Aw); test_free(Bw); test_free(Cw); test_free(Dw); test_free_2D(Av); test_free_2D(Bv); test_free_2D(Cv); test_free_2D(Dv); test_free(R); MSG("done."); gasnet_exit(0); return 0; }
if_pf (GASNETC_LONG_ASYNC_REQ(category, is_request, is_sync_request)) p_sreq = gasnetc_alloc_send_req(); else p_sreq = &sreq; mxm_sreq = &p_sreq->mxm_sreq; #if GASNET_DEBUG_AM MXM_LOG("[msg 0x%02x%02x] [pid %d] %s %s%s%s%s, %d --> %d, nbytes = %d, numargs = %d\n", (is_request) ? (uint8_t)gasneti_mynode : (uint8_t)dest, msg_num, getpid(), am_category_str[category], (is_request && is_sync_request) ? "sync request" : "", (is_request && !is_sync_request) ? "ASYNC request" : "", (!is_request && is_sync_request) ? "response to sync request" : "", (!is_request && !is_sync_request) ? "response to ASYNC request" : "", (uint32_t)gasnet_mynode(), (uint32_t)dest, nbytes, numargs); #endif gasneti_assert((category & ~3) == 0); gasneti_assert(numargs <= GASNETC_MAX_ARGS); /* * From a sender's point of view, the request and reply functions block * until the message is sent. A message is defined to be sent once it is * safe for the caller to reuse the memory containing the message (except * for gasnet_RequestLongAsyncM() case). * * In implementations which copy or buffer messages for transmission, * the definition still holds: message sent means the layer has copied * the message and promises to deliver the copy with its "best effort", * and the original message storage may be reused.
int main(int argc, char **argv) { /* call startup */ GASNET_Safe(gasnet_init(&argc, &argv)); /* parse arguments */ arg = 1; while (argc > arg) { if (!strcmp(argv[arg], "-in")) { insegment = 1; ++arg; } else if (!strcmp(argv[arg], "-out")) { insegment = 0; ++arg; } else if (!strcmp(argv[arg], "-f")) { firstlastmode = 1; ++arg; } else if (!strcmp(argv[arg], "-a")) { fullduplexmode = 1; ++arg; } else if (!strcmp(argv[arg], "-p")) { do_puts = 1; numflavors++; ++arg; } else if (!strcmp(argv[arg], "-g")) { do_gets = 1; numflavors++; ++arg; } else if (!strcmp(argv[arg], "-s")) { do_amshort = 1; numflavors++; ++arg; } else if (!strcmp(argv[arg], "-m")) { do_ammedium = 1; numflavors++; ++arg; } else if (!strcmp(argv[arg], "-l")) { do_amlong = 1; numflavors++; ++arg; } else if (!strcmp(argv[arg], "-b")) { do_bulk = 1; ++arg; } else if (!strcmp(argv[arg], "-n")) { do_nonbulk = 1; ++arg; } else if (!strcmp(argv[arg], "-v")) { do_value = 1; ++arg; } else if (!strcmp(argv[arg], "-i")) { do_implicit = 1; numsync++; ++arg; } else if (!strcmp(argv[arg], "-e")) { do_explicit = 1; numsync++; ++arg; } else if (!strcmp(argv[arg], "-k")) { do_blocking = 1; numsync++; ++arg; } else if (argv[arg][0] == '-') { help = 1; ++arg; } else break; } if (fullduplexmode && firstlastmode) help = 1; if (argc > arg+3) help = 1; if (argc > arg) { iters = atoi(argv[arg]); arg++; } if (!iters) iters = 10; if (argc > arg) { maxdepth = atoi(argv[arg]); arg++; } if (!maxdepth) maxdepth = 1024; /* 1024 default */ if (argc > arg) { maxsz = atoi(argv[arg]); arg++; } if (!maxsz) maxsz = 2*1024*1024; /* 2 MB default */ #ifdef GASNET_SEGMENT_EVERYTHING if (maxsz > TEST_SEGSZ) { MSG("maxsz must be <= %lu on GASNET_SEGMENT_EVERYTHING",(unsigned long)TEST_SEGSZ); gasnet_exit(1); } #endif GASNET_Safe(gasnet_attach(htable, sizeof(htable)/sizeof(gasnet_handlerentry_t), TEST_SEGSZ_REQUEST, TEST_MINHEAPOFFSET)); test_init("testqueue",1,"[-in|-out|-a|-f] (iters) (maxdepth) (maxsz)\n" " The 'in' or 'out' option selects whether the initiator-side\n" " memory is in the GASNet segment or not (default is not).\n" " The -a option enables full-duplex mode, where all nodes send.\n" " The -f option enables 'first/last' mode, where the first node\n" " sends to the last, while all other nodes sit idle.\n" " Test types to run: (defaults to everything)\n" " -p : puts\n" " -g : gets\n" " -s : AMShort\n" " -m : AMMedium\n" " -l : AMLong\n" " -n : Test non-bulk put/gets\n" " -b : Test bulk put/gets\n" " -v : Test value-based put/gets\n" " -i : Test implicit-handle put/gets\n" " -e : Test explicit-handle put/gets\n" " -k : Test blocking put/gets\n"); if (help) test_usage(); min_payload = 1; max_payload = maxsz; if (numflavors == 0) { /* default to all */ do_puts = 1; do_gets = 1; do_amshort = 1; do_ammedium = 1; do_amlong = 1; } if (numsync == 0) { /* default to all */ do_implicit = 1; do_explicit = 1; do_blocking = 1; } if (!do_bulk && !do_nonbulk && !do_value) { do_bulk = 1; do_nonbulk = 1; do_value = 1; } if (!do_implicit && !do_explicit && !do_blocking) { do_implicit = 1; do_explicit = 1; do_blocking = 1; } if (max_payload < min_payload) { printf("ERROR: maxsz must be >= %i\n",min_payload); gasnet_exit(1); } /* get SPMD info */ myproc = gasnet_mynode(); numprocs = gasnet_nodes(); if (!firstlastmode) { /* Only allow 1 or even number for numprocs */ if (numprocs > 1 && numprocs % 2 != 0) { MSG0("WARNING: This test requires a unary or even number of nodes. Test skipped.\n"); gasnet_exit(0); /* exit 0 to prevent false negatives in test harnesses for smp-conduit */ } } /* Setting peer thread rank */ if (firstlastmode) { peerproc = numprocs-1; iamsender = (myproc == 0); iamrecver = (myproc == numprocs-1); multisender = 0; } else if (numprocs == 1) { peerproc = 0; iamsender = 1; iamrecver = 1; multisender = 0; } else { peerproc = (myproc % 2) ? (myproc - 1) : (myproc + 1); iamsender = (fullduplexmode || myproc % 2 == 0); iamrecver = (fullduplexmode || !iamsender); multisender = (fullduplexmode || numprocs >= 4); } multisender = 1; /* messes up output on some systems */ myseg = TEST_SEG(myproc); tgtmem = TEST_SEG(peerproc); if (insegment) { msgbuf = (void *) myseg; } else { alloc = (void *) test_calloc(maxsz+PAGESZ,1); /* use calloc to prevent valgrind warnings */ msgbuf = (void *) alignup(((uintptr_t)alloc), PAGESZ); /* ensure page alignment of base */ } assert(((uintptr_t)msgbuf) % PAGESZ == 0); MSG0("Running %squeue test with local addr %sside segment, iters=%i, maxdepth=%i, sz: %i...%i", firstlastmode ? "first/last " : (fullduplexmode ? "full-duplex ": ""), insegment ? "in" : "out", iters, maxdepth, min_payload, max_payload); MSG0("x-axis: queue depth, y-axis: message size, injection time in microseconds\n"); BARRIER(); handles = (gasnet_handle_t *) test_malloc(sizeof(gasnet_handle_t) * maxdepth); vghandles = (gasnet_valget_handle_t *) test_malloc(sizeof(gasnet_valget_handle_t) * maxdepth); do_bulkputgets(); do_nonbulkputgets(); do_valueputgets(); do_blockingputgets(); do_amtests(); BARRIER(); test_free(handles); if (!insegment) { test_free(alloc); } gasnet_exit(0); return 0; }
int main(int argc, char **argv) { int arg; int iters = 0; int size = 0; int j; int help = 0; /* call startup */ GASNET_Safe(gasnet_init(&argc, &argv)); GASNET_Safe(gasnet_attach(NULL, 0, TEST_SEGSZ_REQUEST, TEST_MINHEAPOFFSET)); test_init("testalign", 1, "[-in|-out] (iters) (size)\n" " The 'in' or 'out' option selects whether the initiator-side\n" " memory is in the GASNet segment or not (default is not).\n" " The -m option enables MB/sec units for bandwidth output (MB=2^20 bytes)."); /* parse arguments */ arg = 1; while (argc > arg) { if (!strcmp(argv[arg], "-in")) { insegment = 1; ++arg; } else if (!strcmp(argv[arg], "-out")) { insegment = 0; ++arg; } else if (!strcmp(argv[arg], "-m")) { unitsMB = 1; ++arg; } else if (argv[arg][0] == '-') { help = 1; ++arg; } else break; } if (help || argc > arg+2) test_usage(); if (argc > arg) iters = atoi(argv[arg++]); if (!iters) iters = 1000; if (argc > arg) size = atoi(argv[arg++]); if (!size) size = DEFAULT_SZ; /* get SPMD info */ myproc = gasnet_mynode(); numprocs = gasnet_nodes(); /* Only allow even number for numprocs */ if (numprocs % 2 != 0) { MSG("WARNING: This test requires an even number of nodes. Test skipped.\n"); gasnet_exit(0); /* exit 0 to prevent false negatives in test harnesses for smp-conduit */ } /* Setting peer thread rank */ peerproc = (myproc % 2) ? (myproc - 1) : (myproc + 1); iamsender = (myproc % 2 == 0); rembuf = (void *) TEST_SEG(peerproc); /* initialize global data in my thread */ if (insegment) { locbuf = (void *)TEST_MYSEG(); } else { /* size + 1 page of alignment + initial alignment padding of PAGESZ-1 */ uintptr_t tmp = (uintptr_t) test_malloc(size + 2 * PAGESZ - 1); locbuf = (void *)((tmp + PAGESZ - 1) & ~(PAGESZ - 1)); } for (j = 1; j <= PAGESZ; j *= 2) oneway_test(iters, size, j); for (j = 1; j <= PAGESZ; j *= 2) oneway_nbi_test(iters, size, j); for (j = 1; j <= PAGESZ; j *= 2) oneway_nb_test(iters, size, j); BARRIER(); gasnet_exit(0); return 0; }