/*
* Helper functions
*/
static xlator_t *
helper_xlator_init(uint32_t num_types)
{
xlator_t *xl;
int i, ret;
REQUIRE(num_types > 0);
xl = test_calloc(1, sizeof(xlator_t));
assert_non_null(xl);
xl->mem_acct.num_types = num_types;
xl->mem_acct.rec = test_calloc(num_types, sizeof(struct mem_acct_rec));
assert_non_null(xl->mem_acct.rec);
xl->ctx = test_calloc(1, sizeof(glusterfs_ctx_t));
assert_non_null(xl->ctx);
for (i = 0; i < num_types; i++) {
ret = LOCK_INIT(&(xl->mem_acct.rec[i].lock));
assert_int_equal(ret, 0);
}
ENSURE(num_types == xl->mem_acct.num_types);
ENSURE(NULL != xl);
return xl;
}
int main(){
int ch;
print_menu();
do{
printf("Enter your choice: ");
scanf("%d",&ch);
switch(ch){
case TEST_MALLOC:
test_malloc();
break;
case TEST_CALLOC:
test_calloc();
break;
case TEST_REALLOC:
test_realloc();
break;
case TEST_FREE:
test_free();
break;
case TEST_SPACE:
test_get_free_space();
break;
case PRINT_MMAP:
test_print_mmap();
break;
case EXIT:
break;
default: printf("Invalid selection!!! Try Again\n");
}
}while(ch!=EXIT);
return 0;
}
int main(int argc, char**argv)
{
char* buffer[ITER];
int i, j;
debug("Testing malloc\n");
test_malloc();
debug("1/2 done\n");
compute(100000);
test_malloc();
debug("2/2 done\n");
compute(100000);
debug("Testing realloc\n");
test_realloc();
debug("realloc done\n");
compute(100000);
debug("Testing calloc\n");
test_calloc();
debug("calloc done\n");
return 0;
}
PPACKETS
WinPacketsTreeAllocate() {
PPACKETS packets = test_calloc(1, sizeof(*packets));
PPACKET_TREE tree = &packets->tree;
tree->parent = Fake_WinPacketAllocateNonOwned();
tree->upperChild1 = WinPacketClone(tree->parent);
tree->upperChild2 = WinPacketClone(tree->parent);
tree->lowerChild1 = WinPacketClone(tree->upperChild1);
tree->lowerChild2 = WinPacketClone(tree->upperChild1);
tree->lowerChild3 = WinPacketClone(tree->upperChild2);
return packets;
}
static void
test_gf_mem_set_acct_info_memory(void **state)
{
xlator_t *xl;
char *alloc_ptr;
char *temp_ptr;
size_t size;
uint32_t type;
const char *typestr = "TEST";
size = 8196;
type = 9;
// Initialize xl
xl = helper_xlator_init(10);
assert_null(xl->mem_acct.rec[type].typestr);
// Test allocation
temp_ptr = test_calloc(1, size + GF_MEM_HEADER_SIZE + GF_MEM_TRAILER_SIZE);
assert_non_null(temp_ptr);
alloc_ptr = temp_ptr;
gf_mem_set_acct_info(xl, &alloc_ptr, size, type, typestr);
//Check values
assert_ptr_equal(typestr, xl->mem_acct.rec[type].typestr);
assert_int_equal(xl->mem_acct.rec[type].size, size);
assert_int_equal(xl->mem_acct.rec[type].num_allocs, 1);
assert_int_equal(xl->mem_acct.rec[type].total_allocs, 1);
assert_int_equal(xl->mem_acct.rec[type].max_size, size);
assert_int_equal(xl->mem_acct.rec[type].max_num_allocs, 1);
// Check memory
helper_check_memory_headers(temp_ptr, xl, size, type);
// Check that alloc_ptr has been moved correctly
// by gf_mem_set_acct_info
{
mem_header_t *p;
p = (mem_header_t *)temp_ptr;
p++;
p->type = 1234;
assert_int_equal(*(uint32_t *)alloc_ptr, p->type);
}
free(temp_ptr);
helper_xlator_destroy(xl);
}
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) {
/* 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 help=0;
int arg=1;
GASNET_Safe(gex_Client_Init(&myclient, &myep, &myteam, "testam", &argc, &argv, 0));
mynode = gex_TM_QueryRank(myteam);
numnode = gex_TM_QuerySize(myteam);
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], "-sync-req")) {
asynclc = 0;
lc_opt = GEX_EVENT_NOW;
++arg;
} else if (!strcmp(argv[arg], "-async-req")) {
asynclc = 1;
lc_opt = GEX_EVENT_GROUP;
++arg;
} else if (!strcmp(argv[arg], "-fp")) {
use_np = 0;
++arg;
} else if (!strcmp(argv[arg], "-np-cb")) {
use_np = 1;
np_cbuf = 1;
++arg;
} else if (!strcmp(argv[arg], "-np-gb")) {
use_np = 1;
np_cbuf = 0;
++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(gex_Segment_Attach(&mysegment, myteam, TEST_SEGSZ_REQUEST));
GASNET_Safe(gex_EP_RegisterHandlers(myep, htable, sizeof(htable)/sizeof(gex_AM_Entry_t)));
#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 '-sync-req' or '-async-req' option selects synchronous or asynchronous\n"
" local completion of Medium and Long Requests (default is synchronous).\n"
" The '-fp', '-np-gb' or '-np-cb' option selects Fixed- or Negotiated-Payload\n"
" for Medium and Long AMs, as follows:\n"
" -fp: Fixed-Payload (default)\n"
" -np-gb: Negotiated-Payload with GASNet-provided buffer\n"
" -np-cb: Negotiated-Payload with client-provided buffer\n"
" 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);
}
if (src_mode == SRC_MEMCPY) {
zero_buffer = test_calloc(maxsz, 1);
}
np_lc_opt = np_cbuf ? lc_opt : NULL;
if (crossmachinemode) {
if ((numnode%2) && (mynode == numnode-1)) {
sender = 1;
peer = mynode;
} else {
gex_Rank_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;
}
}
gex_Event_t *tmp_lc_opt = use_np ? np_lc_opt : lc_opt;
gex_Flags_t flags = use_np ? ( np_cbuf ? GEX_FLAG_AM_PREPARE_LEAST_CLIENT
: GEX_FLAG_AM_PREPARE_LEAST_ALLOC) : 0;
maxmedreq = MIN(maxsz, gex_AM_MaxRequestMedium(myteam,peer,tmp_lc_opt,flags,0));
maxmedrep = MIN(maxsz, gex_AM_MaxReplyMedium (myteam,peer,GEX_EVENT_NOW,flags,0));
maxlongreq = MIN(maxsz, gex_AM_MaxRequestLong (myteam,peer,tmp_lc_opt,flags,0));
maxlongrep = MIN(maxsz, gex_AM_MaxReplyLong (myteam,peer,GEX_EVENT_NOW,flags,0));
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_GEX_RMA_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"
" %ssynchronous LC for Requests%s\n"
" %s\n"
" %s\n"
PAR_FMT
" ...\n",
iters,
(crossmachinemode ? "cross-machine ": ""),
(insegment ? "in" : "out"),
(insegment ? " (default)" : ""),
(asynclc ? "a": ""),
(asynclc ? "": " (default)"),
(!use_np ? "fixed-Payload (default)"
:(np_cbuf ? "negotiated-Payload with client-provided buffer"
: "negotiated-Payload with GASNet-provided buffer")),
((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;
}
/*
* Take the amount of memory to allocate in bytes as a command-line argument
* and call test_malloc with that amount of memory.
*/
int
main(int argc, char *argv[])
{
size_t size, max;
size_t limit = 0;
int willfail = 0;
unsigned char code;
if (argc < 3)
die("Usage error. Type, size, and limit must be given.");
errno = 0;
size = strtol(argv[2], 0, 10);
if (size == 0 && errno != 0)
sysdie("Invalid size");
errno = 0;
limit = strtol(argv[3], 0, 10);
if (limit == 0 && errno != 0)
sysdie("Invalid limit");
/* If the code is capitalized, install our customized error handler. */
code = argv[1][0];
if (isupper(code)) {
xmalloc_error_handler = test_handler;
code = tolower(code);
}
/*
* Decide if the allocation should fail. If it should, set willfail to 2,
* so that if it unexpectedly succeeds, we exit with a status indicating
* that the test should be skipped.
*/
max = size;
if (code == 's' || code == 'n' || code == 'a' || code == 'v') {
max += size;
if (limit > 0)
limit += size;
}
if (limit > 0 && max > limit)
willfail = 2;
/*
* If a memory limit was given and we can set memory limits, set it.
* Otherwise, exit 2, signalling to the driver that the test should be
* skipped. We do this here rather than in the driver due to some
* pathological problems with Linux (setting ulimit in the shell caused
* the shell to die).
*/
if (limit > 0) {
#if HAVE_SETRLIMIT && defined(RLIMIT_AS)
struct rlimit rl;
void *tmp;
size_t test_size;
rl.rlim_cur = limit;
rl.rlim_max = limit;
if (setrlimit(RLIMIT_AS, &rl) < 0) {
syswarn("Can't set data limit to %lu", (unsigned long) limit);
exit(2);
}
if (size < limit || code == 'r') {
test_size = code == 'r' ? 10 : size;
if (test_size == 0)
test_size = 1;
tmp = malloc(test_size);
if (tmp == NULL) {
syswarn("Can't allocate initial memory of %lu (limit %lu)",
(unsigned long) test_size, (unsigned long) limit);
exit(2);
}
free(tmp);
}
#else
warn("Data limits aren't supported.");
exit(2);
#endif
}
switch (code) {
case 'c': exit(test_calloc(size) ? willfail : 1);
case 'm': exit(test_malloc(size) ? willfail : 1);
case 'r': exit(test_realloc(size) ? willfail : 1);
case 's': exit(test_strdup(size) ? willfail : 1);
case 'n': exit(test_strndup(size) ? willfail : 1);
case 'a': exit(test_asprintf(size) ? willfail : 1);
case 'v': exit(test_vasprintf(size) ? willfail : 1);
default:
die("Unknown mode %c", argv[1][0]);
break;
}
exit(1);
}
int main(int argc, char **argv) {
int iters = 0;
int arg;
void *alloc = NULL;
int firstlastmode = 0;
int fullduplexmode = 0;
int crossmachinemode = 0;
int singlesender = 0;
int help = 0;
/* 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], "-sl")) {
++arg;
if (argc > arg) { stridelevels = atoi(argv[arg]); arg++; }
else help = 1;
} else if (!strcmp(argv[arg], "-mincontig")) {
++arg;
if (argc > arg) { min_contig = atoi(argv[arg]); arg++; }
else help = 1;
} else if (!strcmp(argv[arg], "-maxcontig")) {
++arg;
if (argc > arg) { max_contig = atoi(argv[arg]); arg++; }
else help = 1;
} else if (!strcmp(argv[arg], "-contigfactor")) {
++arg;
if (argc > arg) { contigfactor = atoi(argv[arg]); arg++; }
else help = 1;
} else if (!strcmp(argv[arg], "-mindata")) {
++arg;
if (argc > arg) { min_payload = atoi(argv[arg]); arg++; }
else help = 1;
} else if (!strcmp(argv[arg], "-maxdata")) {
++arg;
if (argc > arg) { max_payload = atoi(argv[arg]); arg++; }
else help = 1;
} else if (!strcmp(argv[arg], "-datafactor")) {
++arg;
if (argc > arg) { datafactor = atoi(argv[arg]); arg++; }
else help = 1;
} else if (!strcmp(argv[arg], "-densitysteps")) {
++arg;
if (argc > arg) { densitysteps = atoi(argv[arg]); arg++; }
else help = 1;
} else if (!strcmp(argv[arg], "-f")) {
firstlastmode = 1;
++arg;
} else if (!strcmp(argv[arg], "-c")) {
crossmachinemode = 1;
++arg;
} else if (!strcmp(argv[arg], "-a")) {
fullduplexmode = 1;
++arg;
} else if (!strcmp(argv[arg], "-p")) {
dogets = 0; doputs = 1;
++arg;
} else if (!strcmp(argv[arg], "-g")) {
dogets = 1; doputs = 0;
++arg;
} else if (!strcmp(argv[arg], "-r")) {
remotecontig = 1;
++arg;
} else if (!strcmp(argv[arg], "-l")) {
localcontig = 1;
++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) { TEST_SECTION_PARSE(argv[arg]); arg++; }
if (min_contig && max_contig && min_contig > max_contig) { ERR("min_contig > max_contig"); help = 1; }
if (min_payload && max_payload && min_payload > max_payload) { ERR("min_payload > max_payload"); help = 1; }
if (min_payload && min_contig && min_payload < min_contig) { ERR("min_payload < min_contig"); help = 1; }
if (max_contig && max_payload && max_contig > max_payload) { ERR("max_contig > max_payload"); help = 1; }
if (contigfactor < 2) { ERR("contigfactor < 2"); help = 1; }
if (datafactor < 2) { ERR("datafactor < 2"); help = 1; }
if (!max_payload) max_payload = 2*1024*1024; /* 2 MB default */
#ifdef GASNET_SEGMENT_EVERYTHING
maxsz = gasnet_getMaxGlobalSegmentSize();
#else
maxsz = 16*1024*1024;
#endif
max_payload = (int)MIN(maxsz, max_payload);
maxsz = MIN(((uint64_t)max_payload) * densitysteps,maxsz);
if (!min_contig) min_contig = 8;
if (!max_contig) max_contig = MIN(256*1024,max_payload);
if (!min_payload) min_payload = min_contig;
GASNET_Safe(gasnet_attach(NULL, 0, TEST_SEGSZ_REQUEST, TEST_MINHEAPOFFSET));
test_init("testvisperf",1, "[options] (iters) (test_sections)\n"
" -p/-g selects puts only or gets only (default is both).\n"
" -r/-l selects remotely contiguous or locally contiguous (default is neither).\n"
" -mindata/-maxdata <sz> \n"
" selects sz as min/max data payload per operation.\n"
" -mincontig/-maxcontig <sz> \n"
" selects sz as min/max contig size.\n"
" -datafactor/-contigfactor <f> \n"
" selects f as growth factor for data/contig sizes.\n"
" -densitysteps <d> \n"
" selects d density steps, inclusive from 100%..100/d%\n"
" -sl <n> selects n striding levels (default is 2).\n"
" -in/-out selects whether the initiator-side\n"
" memory is in the GASNet segment or not (default is not).\n"
" -a enables full-duplex mode, where all nodes send.\n"
" -c enables cross-machine pairing, default is nearest neighbor.\n"
" -f enables 'first/last' mode, where the first/last\n"
" nodes communicate with each other, while all other nodes sit idle.");
if (help || argc > arg) test_usage();
/* 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 = (myproc == 0 ? numprocs-1 : 0);
iamsender = (fullduplexmode ? myproc == 0 || myproc == numprocs-1 : myproc == 0);
} else if (numprocs == 1) {
peerproc = 0;
iamsender = 1;
} else if (crossmachinemode) {
if (myproc < numprocs / 2) {
peerproc = myproc + numprocs/2;
iamsender = 1;
} else {
peerproc = myproc - numprocs/2;
iamsender = fullduplexmode;
}
} else {
peerproc = (myproc % 2) ? (myproc - 1) : (myproc + 1);
iamsender = (fullduplexmode || myproc % 2 == 0);
}
singlesender = (numprocs == 1) || ((numprocs == 2 || firstlastmode) && !fullduplexmode);
Rbase = TEST_SEG(peerproc);
if (insegment) {
Lbase = TEST_SEG(myproc);
} else {
alloc = test_calloc(maxsz+PAGESZ,1); /* use calloc to prevent valgrind warnings */
Lbase = alignup_ptr(alloc, PAGESZ); /* ensure page alignment of base */
}
assert(((uintptr_t)Lbase) % PAGESZ == 0);
if (myproc == 0) {
MSG0("Running %i iterations of %s%s%snon-contiguous put/get%s%s\n local data %s-segment for sizes: %i...%i\n",
iters,
(firstlastmode ? "first/last " : ""),
(fullduplexmode ? "full-duplex ": ""),
(crossmachinemode ? "cross-machine ": ""),
(remotecontig?"(remotely-contiguous)":""),
(localcontig?"(locally-contiguous)":""),
insegment ? "in" : "out",
min_payload, max_payload);
printf("rows are databytes/op : bandwidth values in MB/s\n");
}
BARRIER();
{ int contigsz;
int rawdatasz;
int isget;
test_vis_t viscat;
for (viscat = TEST_V; viscat <= TEST_S; viscat++) {
for (isget = 0; isget < 2; isget++) {
if (TEST_SECTION_BEGIN_ENABLED()) {
if (isget && !dogets) continue;
if (!isget && !doputs) continue;
if (!dovis[viscat]) continue;
for (contigsz = min_contig; contigsz <= max_contig; contigsz *= contigfactor) {
int di;
size_t lastdatasz = 0;
if (contigsz > max_payload) continue;
if (!myproc) {
printf("\n%c: %s %s CONTIGSZ = %i\n", TEST_SECTION_NAME(),
visdesc[(int)viscat], (isget?"GET":"PUT"), contigsz);
printf(" density:");
for (di = 0; di < densitysteps; di++) {
printf("%8i%%", (int)((densitysteps-di)*100.0/densitysteps));
}
printf("\n");
}
for (rawdatasz = min_payload; rawdatasz <= max_payload; rawdatasz *= datafactor) {
char mystr[255];
size_t datasz = aligndown(rawdatasz,contigsz);
if (datasz == lastdatasz) continue;
lastdatasz = datasz;
if (singlesender) snprintf(mystr, sizeof(mystr), "%8i: ", (int)datasz);
else snprintf(mystr, sizeof(mystr), "P%i: %6i: ", myproc, (int)datasz);
for (di = 0; di < densitysteps; di++) {
gasnett_tick_t begin=0, end=0;
size_t Lcnt = (localcontig ? 1 : datasz/contigsz);
size_t Rcnt = (remotecontig? 1 : datasz/contigsz);
size_t Lsz = datasz/Lcnt;
size_t Rsz = datasz/Rcnt;
void **Lilist = NULL;
void **Rilist = NULL;
gasnet_memvec_t *Lvlist = NULL;
gasnet_memvec_t *Rvlist = NULL;
size_t *Lstrides = NULL;
size_t *Rstrides = NULL;
size_t *LRcount = NULL;
size_t stride = contigsz*(((double)densitysteps)/(densitysteps-di));
if (stride * MAX(Lcnt,Rcnt) > maxsz) { strcat(mystr," - "); continue; }
if (iamsender) { /* setup metadata */
switch (viscat) {
case TEST_V:
Lvlist = make_vlist(Lbase, stride, Lcnt, Lsz);
Rvlist = make_vlist(Rbase, stride, Rcnt, Rsz);
break;
case TEST_I:
Lilist = make_ilist(Lbase, stride, Lcnt, Lsz);
Rilist = make_ilist(Rbase, stride, Rcnt, Rsz);
break;
case TEST_S: {
size_t chunkcnt = datasz/contigsz;
int dim;
Lstrides = test_malloc(sizeof(size_t)*stridelevels);
Rstrides = test_malloc(sizeof(size_t)*stridelevels);
LRcount = test_malloc(sizeof(size_t)*(stridelevels+1));
LRcount[0] = contigsz;
Lstrides[0] = (localcontig ? contigsz : stride);
Rstrides[0] = (remotecontig ? contigsz : stride);
for (dim = 1; dim < stridelevels; dim++) {
size_t factor = 1, fi;
for (fi = 1; fi <= chunkcnt/(2*(stridelevels-dim)); fi++) /* choose a reasonable factor */
if (chunkcnt/fi*fi == chunkcnt) factor = fi;
LRcount[dim] = factor;
chunkcnt /= factor;
Lstrides[dim] = LRcount[dim]*Lstrides[dim-1];
Rstrides[dim] = LRcount[dim]*Rstrides[dim-1];
}
LRcount[stridelevels] = chunkcnt;
{ size_t tmp = 1;
for (dim = 0; dim <= stridelevels; dim++) tmp *= LRcount[dim];
assert(tmp == datasz);
}
break;
}
}
}
#define DOIT(iters) do { \
int i; \
switch (viscat) { \
case TEST_V: \
for (i = 0; i < iters; i++) { \
if (isget) gasnet_getv_nbi_bulk(Lcnt,Lvlist,peerproc,Rcnt,Rvlist); \
else gasnet_putv_nbi_bulk(peerproc,Rcnt,Rvlist,Lcnt,Lvlist); \
} \
break; \
case TEST_I: \
for (i = 0; i < iters; i++) { \
if (isget) gasnet_geti_nbi_bulk(Lcnt,Lilist,Lsz,peerproc,Rcnt,Rilist,Rsz); \
else gasnet_puti_nbi_bulk(peerproc,Rcnt,Rilist,Rsz,Lcnt,Lilist,Lsz); \
} \
break; \
case TEST_S: \
for (i = 0; i < iters; i++) { \
if (isget) gasnet_gets_nbi_bulk(Lbase,Lstrides,peerproc,Rbase,Rstrides, \
LRcount,stridelevels); \
else gasnet_puts_nbi_bulk(peerproc,Rbase,Rstrides,Lbase,Lstrides, \
LRcount,stridelevels); \
} \
break; \
} \
gasnet_wait_syncnbi_all(); \
} while (0)
if (iamsender) DOIT(1); /* pay some warm-up costs */
BARRIER();
if (iamsender) {
begin = gasnett_ticks_now();
DOIT(iters);
end = gasnett_ticks_now();
}
BARRIER();
if (iamsender) {
char tmp[80];
double secs = gasnett_ticks_to_ns(end - begin)/1.0E9;
double dataMB = ((double)datasz) * iters / (1024*1024);
snprintf(tmp, sizeof(tmp), " %8.3f", dataMB / secs);
strcat(mystr, tmp);
}
if (Lilist) test_free(Lilist);
if (Rilist) test_free(Rilist);
if (Lvlist) test_free(Lvlist);
if (Rvlist) test_free(Rvlist);
if (Lstrides) test_free(Lstrides);
if (Rstrides) test_free(Rstrides);
if (LRcount) test_free(LRcount);
}
if (iamsender) { printf("%s\n", mystr); fflush(stdout); }
BARRIER();
}
}
}
}
}
}
BARRIER();
if (alloc) test_free(alloc);
gasnet_exit(0);
return 0;
}