14 #include <sys/types.h> 28 static struct timeval tv0 = {.tv_sec = 0};
31 cc = gettimeofday(&tv, 0);
33 if (tv0.tv_sec == 0) {
35 assert(tv0.tv_sec != 0);
37 double dt = ((double)(tv.tv_sec - tv0.tv_sec)
38 + ((double)(tv.tv_usec - tv0.tv_usec) * 1e-6));
48 assert(kvs0 == 0 && kv0.klen == 0 && kv0.vlen == 0 && kvo != 0);
53 for (
int i = 0; i < N; i++) {
54 snprintf(k, 80,
"key%d", i);
55 snprintf(v, 80,
"value%d", i);
57 .klen = (int)(strlen(k) + 1), .vlen = (
int)(strlen(v) + 1),
60 assert(cc == MPI_SUCCESS);
70 assert(kvs0 != 0 && kvo != 0);
73 cc = sscanf((&((
char *)kv0.k.p)[3]),
"%d%c", &x, &gomi);
75 snprintf(buf,
sizeof(buf),
"newvalue%d", x);
76 int vlen = (int)(strlen(buf) + 1);
82 assert(cc == MPI_SUCCESS);
90 aggregatevalues0(
const struct kmr_kv_box kv[],
const long n,
94 MPI_Comm_size(MPI_COMM_WORLD, &nprocs);
95 MPI_Comm_rank(MPI_COMM_WORLD, &rank);
97 for (
int i = 0; i < n; i++) {
100 switch (kvs->c.key_data) {
102 assert(kvs->c.key_data != KMR_KV_BAD);
105 assert(kv[i].klen == b0.klen
106 && kv[i].k.i == b0.k.i);
109 assert(kv[i].klen == b0.klen
110 && kv[i].k.d == b0.k.d);
114 case KMR_KV_POINTER_OWNED:
115 case KMR_KV_POINTER_UNMANAGED:
116 assert(kv[i].klen == b0.klen
117 && memcmp(kv[i].k.p, b0.k.p, (
size_t)b0.klen) == 0);
127 snprintf(buf, 48,
"%ld_*_%s", n, kv[0].v.p);
128 int len = (int)(strlen(buf) + 1);
134 assert(cc == MPI_SUCCESS);
142 KMR *mr = kvs0->c.mr;
147 cc = sscanf((&((
char *)kv0.k.p)[3]),
"%d%c", &x, &gomi);
149 snprintf(buf,
sizeof(buf),
"%d_*_newvalue%d", mr->nprocs, x);
150 assert(strlen(kv0.v.p) == strlen(buf));
151 size_t len = strlen(buf);
152 assert(strncmp((kv0.v.p), buf, len) == 0);
160 simple0(
int nprocs,
int rank, _Bool pushoff)
162 MPI_Barrier(MPI_COMM_WORLD);
165 if (rank == 0) {printf(
"CHECK SIMPLE OPERATIONS...\n");}
167 if (rank == 0) {printf(
"CHECK PUSH-OFF KVS...\n");}
176 mr->pushoff_stat = 1;
177 mr->preset_block_size = 750;
184 MPI_Barrier(mr->comm);
186 if (rank == 0) {printf(
"ADD (%d elements)\n", N);}
192 assert(cc == MPI_SUCCESS);
196 assert(cc == MPI_SUCCESS);
201 MPI_Barrier(mr->comm);
203 if (rank == 0) {printf(
"REPLICATE\n");}
209 assert(cc == MPI_SUCCESS);
213 assert(cc == MPI_SUCCESS);
214 assert(cnt1 == (N * nprocs));
218 MPI_Barrier(mr->comm);
220 if (rank == 0) {printf(
"PACK+UNPACK\n");}
227 assert(cc == MPI_SUCCESS && data != 0 && sz != 0);
229 assert(cc == MPI_SUCCESS);
233 assert(cc == MPI_SUCCESS);
235 assert((kvs1r->c.key_data == KMR_KV_OPAQUE
236 || kvs1r->c.key_data == KMR_KV_CSTRING)
237 && (kvs1r->c.value_data == KMR_KV_OPAQUE
238 || kvs1r->c.value_data == KMR_KV_CSTRING));
242 MPI_Barrier(mr->comm);
244 if (rank == 0) {printf(
"MAP\n");}
254 __FILE__, __LINE__, __func__);
256 cc =
kmr_map(kvs1r, kvs2, 0, kmr_noopt, replacevalues0);
257 assert(cc == MPI_SUCCESS);
261 assert(cc == MPI_SUCCESS);
262 assert(cnt2 == (N * nprocs));
266 MPI_Barrier(mr->comm);
268 if (rank == 0) {printf(
"SHUFFLE\n");}
274 assert(cc == MPI_SUCCESS);
285 assert(cc == MPI_SUCCESS);
290 assert(cc == MPI_SUCCESS);
291 assert(cnt3 == (N * nprocs));
295 MPI_Barrier(mr->comm);
297 if (rank == 0) {printf(
"REDUCE\n");}
302 cc =
kmr_reduce(kvs3, kvs4, 0, kmr_noopt, aggregatevalues0);
303 assert(cc == MPI_SUCCESS);
309 assert(cc == MPI_SUCCESS);
314 MPI_Barrier(mr->comm);
316 if (rank == 0) {printf(
"GATHER\n");}
323 assert(cc == MPI_SUCCESS);
327 assert(cc == MPI_SUCCESS);
332 cc =
kmr_map(kvs5, 0, 0, kmr_noopt, checkkeyvalues0);
333 assert(cc == MPI_SUCCESS);
335 if (pushoff && mr->pushoff_stat) {
336 char *s =
"STATISTICS on push-off kvs:\n";
337 kmr_print_statistics_on_pushoff(mr, s);
341 assert(cc == MPI_SUCCESS);
350 assert(mr->rank == 0);
353 for (
int i = 0; i < NN; i++) {
355 .klen =
sizeof(long),
356 .vlen =
sizeof(
long),
369 assert(kv0.k.i == i && kv0.v.i == i);
376 simple1(
int nprocs,
int rank)
378 MPI_Barrier(MPI_COMM_WORLD);
379 if (rank == 0) {printf(
"DISTIBUTE\n");}
386 const long NN = MM * nprocs;
397 assert(kvs1->c.element_count == MM);
406 assert(kvs3->c.element_count == MM);
417 kmr_map(kvs5, 0, 0, kmr_noopt, checksorted1);
425 simple2(
int nprocs,
int rank)
427 MPI_Barrier(MPI_COMM_WORLD);
429 if (rank == 0) {printf(
"CHECK OPERATIONS WITH EMPTY KVS...\n");}
442 assert(cc == MPI_SUCCESS);
446 assert(cc == MPI_SUCCESS);
453 assert(cc == MPI_SUCCESS);
458 cc =
kmr_map(kvs1, kvs2, 0, kmr_noopt, 0);
459 assert(cc == MPI_SUCCESS);
465 assert(cc == MPI_SUCCESS);
471 assert(cc == MPI_SUCCESS);
476 cc =
kmr_sort(kvs4, kvs5, kmr_noopt);
477 assert(cc == MPI_SUCCESS);
480 assert(cc == MPI_SUCCESS);
482 assert(cc == MPI_SUCCESS);
488 assert(cc == MPI_SUCCESS);
491 assert(cc == MPI_SUCCESS);
493 KMR_KVS *vec[] = {kvs70, kvs71};
495 assert(cc == MPI_SUCCESS);
497 assert(cc == MPI_SUCCESS);
500 assert(cc == MPI_SUCCESS);
506 simple3(
int nprocs,
int rank)
508 MPI_Barrier(MPI_COMM_WORLD);
510 if (rank == 0) {printf(
"CHECK LOADING OPTIONS (PROPERTY LIST)...\n");}
514 static char props[] =
515 "# Test file for property loader.\n" 520 "key4\\\n" " " ":value4\n" 521 "ke\\\n" " " "y5=val\\\n" " " "ue5\n" 522 "ke\\\n" " " "\\\n" " " "y6\\\n" 523 "=val\\\n" " " "\\\n" " " "ue6\n" 524 "key\\u0037=\\u0076alue7\n" 525 "key#is!anything=value#is!much=more\n";
527 static char *pairs[][2] =
536 {
"key#is!anything",
"value#is!much=more"}};
538 int npairs = (
sizeof(pairs) / (
sizeof(
char *) * 2));
544 system(
"rm -f properties");
545 FILE *f = fopen(
"properties",
"w");
547 size_t cx = fwrite(props, (
sizeof(props) - 1), 1, f);
554 MPI_Info_create(&info);
557 assert(cc == MPI_SUCCESS);
565 cc = MPI_Info_get_nkeys(info, &nkeys);
566 assert(cc == MPI_SUCCESS);
568 assert((npairs - 2) == nkeys);
569 for (
int i = 0; i < npairs; i++) {
570 if (*pairs[i][0] == 0) {
573 if (*pairs[i][1] == 0) {
576 char *key = pairs[i][0];
577 char value[MPI_MAX_INFO_VAL + 1];
580 cc = MPI_Info_get_valuelen(info, key, &vlen, &flag);
581 assert(cc == MPI_SUCCESS && flag != 0);
582 assert(vlen <= MPI_MAX_INFO_VAL);
583 cc = MPI_Info_get(info, key, MPI_MAX_INFO_VAL, value, &flag);
584 assert(cc == MPI_SUCCESS && flag != 0);
585 assert(strcmp(pairs[i][1], value) == 0);
589 MPI_Info_free(&info);
592 system(
"rm -f properties");
600 simple4(
int nprocs,
int rank)
605 MPI_Barrier(MPI_COMM_WORLD);
607 if (rank == 0) {printf(
"CHECK SORTER (SMALL DATA)...\n");}
627 printf(
"Checking local sort on opaques N=%d\n", N);
628 printf(
"Generating random strings...\n");
633 for (
int i = 0; i < N; i++) {
636 for (
int j = 0; j < (len - 1); j++) {
639 int c0 = (int)(vv % 26);
640 int c1 = (
'A' + (c0 - 0));
651 assert(cc == MPI_SUCCESS);
654 assert(cc == MPI_SUCCESS);
658 if (rank == 0) {printf(
"Sorting (normal)...\n"); fflush(0);}
662 assert(cc == MPI_SUCCESS);
663 if (rank == 0) {printf(
"Checking...\n"); fflush(0);}
666 if (rank == 0) {printf(
"Sorting (shuffle)...\n"); fflush(0);}
670 assert(cc == MPI_SUCCESS);
671 if (rank == 0) {printf(
"Check...\n"); fflush(0);}
675 assert(cc == MPI_SUCCESS);
684 printf(
"Checking local sort on integers N=%d\n", N);
685 printf(
"Generating random numbers...\n");
690 for (
int i = 0; i < N; i++) {
691 long vv = ((mrand48() << 32) ^ mrand48());
693 .klen =
sizeof(long),
694 .vlen =
sizeof(
long),
699 assert(cc == MPI_SUCCESS);
702 assert(cc == MPI_SUCCESS);
704 if (rank == 0) {printf(
"Sorting (normal)...\n"); fflush(0);}
708 assert(cc == MPI_SUCCESS);
710 if (rank == 0) {printf(
"Checking...\n"); fflush(0);}
713 if (rank == 0) {printf(
"Sorting (shuffle)...\n"); fflush(0);}
717 assert(cc == MPI_SUCCESS);
718 if (rank == 0) {printf(
"Checking...\n"); fflush(0);}
722 assert(cc == MPI_SUCCESS);
731 printf(
"Checking local sort on doubles N=%d\n", N);
732 printf(
"Generating random numbers...\n");
737 for (
int i = 0; i < N; i++) {
738 double vv = (drand48() - 0.5) * 10000.0;
740 .klen =
sizeof(double),
741 .vlen =
sizeof(
double),
746 assert(cc == MPI_SUCCESS);
749 assert(cc == MPI_SUCCESS);
751 if (rank == 0) {printf(
"Sorting (normal)...\n"); fflush(0);}
755 assert(cc == MPI_SUCCESS);
757 if (rank == 0) {printf(
"Checking...\n"); fflush(0);}
760 if (rank == 0) {printf(
"Sorting (shuffle)...\n"); fflush(0);}
764 assert(cc == MPI_SUCCESS);
765 if (rank == 0) {printf(
"Checking...\n"); fflush(0);}
769 assert(cc == MPI_SUCCESS);
777 for (
int i = 0; i < N; i++) {
778 memset(k, 0,
sizeof(k));
779 memset(v, 0,
sizeof(v));
780 snprintf(k, (KLEN+1),
"%05d%05d", rank, (N - 1 - i));
781 snprintf(v, (VLEN+1),
"value=%d/%d", rank, i);
783 .klen = KLEN, .vlen = VLEN, .k.p = k, .v.p = v};
785 assert(cc == MPI_SUCCESS);
788 assert(cc == MPI_SUCCESS);
792 assert(cc == MPI_SUCCESS);
797 assert(cc == MPI_SUCCESS);
799 assert(cc == MPI_SUCCESS);
805 MPI_Barrier(MPI_COMM_WORLD);
807 if (rank == 0) {printf(
"SORT (int) nprocs x nprocs data...\n");}
813 for (
int i = 0; i < N; i++) {
814 snprintf(v, 80,
"value=%d/%d", rank, i);
816 .klen = (int)
sizeof(
long),
817 .vlen = (int)(strlen(v) + 1),
821 assert(cc == MPI_SUCCESS);
824 assert(cc == MPI_SUCCESS);
828 assert(cc == MPI_SUCCESS);
834 assert(cc == MPI_SUCCESS);
840 assert(cc == MPI_SUCCESS);
844 assert(cc == MPI_SUCCESS);
850 MPI_Barrier(MPI_COMM_WORLD);
852 if (rank == 0) {printf(
"SORT (int) nprocs data...\n");}
858 if (rank == (nprocs - 1)) {
859 for (
int i = 0; i < N; i++) {
860 snprintf(v, 80,
"value=%d/%d", rank, i);
862 .klen = (int)
sizeof(
long),
863 .vlen = (int)(strlen(v) + 1),
867 assert(cc == MPI_SUCCESS);
871 assert(cc == MPI_SUCCESS);
875 assert(cc == MPI_SUCCESS);
881 assert(cc == MPI_SUCCESS);
887 assert(cc == MPI_SUCCESS);
891 assert(cc == MPI_SUCCESS);
897 MPI_Barrier(MPI_COMM_WORLD);
899 if (rank == 0) {printf(
"SORT (int) N x nprocs x nprocs data...\n");}
904 int N = (100 * nprocs);
905 for (
int i = 0; i < N; i++) {
906 snprintf(v, 80,
"value=%d/%d", rank, i);
908 .klen = (int)
sizeof(
long),
909 .vlen = (int)(strlen(v) + 1),
913 assert(cc == MPI_SUCCESS);
916 assert(cc == MPI_SUCCESS);
920 assert(cc == MPI_SUCCESS);
926 assert(cc == MPI_SUCCESS);
932 assert(cc == MPI_SUCCESS);
936 assert(cc == MPI_SUCCESS);
942 MPI_Barrier(MPI_COMM_WORLD);
944 if (rank == 0) {printf(
"SORT (byte array) nprocs x nprocs data...\n");}
950 for (
int i = 0; i < N; i++) {
951 memset(k, 0,
sizeof(k));
952 memset(v, 0,
sizeof(v));
953 snprintf(k, (KLEN+1),
"%05d%05d", rank, (N - 1 - i));
954 snprintf(v, (VLEN+1),
"value=%d/%d", rank, i);
956 .klen = KLEN, .vlen = VLEN, .k.p = k, .v.p = v};
958 assert(cc == MPI_SUCCESS);
961 assert(cc == MPI_SUCCESS);
965 assert(cc == MPI_SUCCESS);
971 assert(cc == MPI_SUCCESS);
977 assert(cc == MPI_SUCCESS);
981 assert(cc == MPI_SUCCESS);
985 assert(cc == MPI_SUCCESS);
989 kmr_icmp(
const void *a0,
const void *a1)
993 long d = (*p0 - *p1);
994 return ((d == 0) ? 0 : ((d < 0) ? -1 : 1));
1000 simple5(
int nprocs,
int rank)
1002 MPI_Barrier(MPI_COMM_WORLD);
1004 if (rank == 0) {printf(
"CHECK BSEARCH UTILITY...\n");}
1011 #define A0(I) (10 + 10 * (I)) 1014 for (
int i = 0; i < NN; i++) {
1018 for (
int N = 20; N < NN; N++) {
1024 assert(p0 == &a0[0]);
1026 for (
int i = 0; i < N; i++) {
1029 assert(p0 == &a0[i]);
1034 assert(p0 == &a0[N]);
1037 MPI_Barrier(MPI_COMM_WORLD);
1052 for (
int i = 0; i < NN; i++) {
1054 .klen =
sizeof(long),
1055 .vlen =
sizeof(
long),
1069 long *counter = arg;
1070 _Pragma(
"omp critical")
1083 long *counter = arg;
1084 _Pragma(
"omp critical")
1092 simple6(
int nprocs,
int rank)
1094 MPI_Barrier(MPI_COMM_WORLD);
1096 if (rank == 0) {printf(
"CHECK KMR_MAP_FOR_SOME()...\n");}
1104 const long NN = 10000;
1110 kmr_map_once(kvs0, (
void *)&NN, kmr_noopt, 0, addkeys6);
1114 assert(kvs1->c.element_count == NN);
1127 printf(
"ADD ALL count(kvs2)=%ld for %ld (calls=%ld)\n",
1131 assert(c2 > 0 && c2 <= c1);
1134 long e1 = kvs1->c.element_count;
1142 printf(
"ADD NONE count(kvs3)=%ld for %ld (calls=%ld for %ld)\n",
1143 c3, c1, calls3, e1);
1146 assert(c3 == 0 && e1 == calls3);
1152 MPI_Barrier(MPI_COMM_WORLD);
1154 if (rank == 0) {printf(
"CHECK KMR_TAKE_ONE()...\n");}
1161 kmr_map_once(kvs4, (
void *)&ONE, kmr_noopt, 0, addkeys6);
1165 assert(kv.k.i == 0 && kv.v.i == 0);
1169 kmr_map(kvs4, kvs5, &calls4, kmr_noopt, addeach6);
1176 extern void kmr_isort(
void *a,
size_t n,
size_t es,
int depth);
1181 simple7(
int nprocs,
int rank)
1183 MPI_Barrier(MPI_COMM_WORLD);
1185 if (rank == 0) {printf(
"CHECK ISORT UTILITY (local sort)...\n");}
1192 char *fastomp = getenv(
"FLIB_FASTOMP");
1193 if (!(fastomp != 0 && strcmp(fastomp,
"FALSE") == 0)) {
1194 if (rank == 0) {printf(
"Set environment variable FLIB_FASTOMP=FALSE" 1195 " and run again. Otherwise," 1196 " omp_set_num_threads() is ignored.\n");}
1205 long a0[20] = {19, 18, 17, 16, 15, 14, 13, 12, 11, 10,
1206 9, 8, 7, 6, 5, 4, 3, 2, 1, 0};
1207 size_t n0 = (
sizeof(a0) /
sizeof(
long));
1208 for (
int i = 0; i < (int)n0; i++) {
1209 a0[i] += 1000000000000;
1212 if (rank == 0) {printf(
"Sorting data N=%zd\n", n0);}
1217 for (
int i = 0; i < (int)n0; i++) {
1218 assert(a0[i] == (i + 1000000000000));
1230 long *a1 = malloc(
sizeof(
long) * (
size_t)n1);
1233 MPI_Abort(MPI_COMM_WORLD, 1);
1236 if (rank == 0) {printf(
"Sorting data N=%zd\n", n1);}
1239 if (rank == 0) {printf(
"Generating random numbers...\n");}
1242 for (
long i = 0; i < n1; i++) {
1243 a1[i] = ((((long)rand()) << 31) ^ ((long)rand()));
1247 printf(
"Problem...\n");
1248 for (
long i = 0; i < 10; i++) {
1249 printf(
"%ld\n", a1[i]);
1254 if (rank == 0) {printf(
"Sorting (threads=1)...\n");}
1257 double t0 = wtime();
1258 kmr_isort(a1, (
size_t)n1,
sizeof(
long), 0);
1259 double t1 = wtime();
1260 if (rank == 0) {printf(
"time=%f\n", (t1 - t0));}
1264 printf(
"Result...\n");
1265 for (
long i = 0; i < 10; i++) {
1266 printf(
"%ld\n", a1[i]);
1271 if (rank == 0) {printf(
"Checking...\n");}
1273 for (
long i = 0; i < n1; i++) {
1274 assert(a1[i] >= lb);
1288 long *a5 = malloc(
sizeof(
long) * (
size_t)n5);
1291 MPI_Abort(MPI_COMM_WORLD, 1);
1294 if (rank == 0) {printf(
"Sorting data N=%zd\n", n5);}
1296 for (
int threads = 1; threads <= 8; threads *= 2) {
1298 omp_set_num_threads(threads);
1301 int threadsused = 0;
1302 #pragma omp parallel 1304 threadsused = omp_get_num_threads();
1307 if (rank == 0) {printf(
"Generating random numbers...\n");}
1311 for (
long i = 0; i < n5; i++) {
1312 a5[i] = ((((long)rand()) << 31) ^ ((long)rand()));
1315 if (rank == 0) {printf(
"Sorting (threads=%d)...\n", threadsused);}
1318 double t0 = wtime();
1319 kmr_isort(a5, (
size_t)n5,
sizeof(
long), 5);
1320 double t1 = wtime();
1321 if (rank == 0) {printf(
"time=%f\n", (t1 - t0));}
1324 if (rank == 0) {printf(
"Checking...\n");}
1327 long lb5 = LONG_MIN;
1328 for (
long i = 0; i < n5; i++) {
1329 assert(a5[i] >= lb5);
1339 printf(
"NOT OMP\n");
1350 makemanyintegerkeys8(
const struct kmr_kv_box kv0,
1355 long MM = *(
long *)p;
1356 KMR *mr = kvo->c.mr;
1357 int rank = mr->rank;
1358 int nprocs = mr->nprocs;
1359 long cnt = (MM * (nprocs - rank) / nprocs);
1360 for (
long i = 0; i < cnt; i++) {
1363 .klen =
sizeof(long),
1364 .vlen =
sizeof(
long),
1365 .k.i = (rank + (j * nprocs)),
1374 makemanystringkeys8(
const struct kmr_kv_box kv0,
1379 long MM = *(
long *)p;
1380 KMR *mr = kvo->c.mr;
1381 int rank = mr->rank;
1382 int nprocs = mr->nprocs;
1383 long cnt = (MM * (nprocs - rank) / nprocs);
1384 for (
long i = 0; i < cnt; i++) {
1387 snprintf(k, 80,
"key%ld", (rank + (j * nprocs)));
1389 .klen = (int)(strlen(k) + 1),
1390 .vlen =
sizeof(
long),
1403 assert(kv0.v.i > 0);
1415 comparebycanceling8(
const struct kmr_kv_box kv[],
const long n,
1419 for (
long i = 0; i < n; i++) {
1420 assert(kv[i].v.i != 0);
1421 values[i] = kv[i].v.i;
1423 for (
long i = 0; i < n; i++) {
1424 if (values[i] == 0) {
1427 assert(i < (n - 1));
1428 for (
long j = (i + 1); j < n; j++) {
1429 if (values[i] == (- values[j])) {
1434 assert(j != (n - 1));
1438 for (
long i = 0; i < n; i++) {
1439 assert(values[i] == 0);
1445 simple8(
int nprocs,
int rank)
1447 MPI_Barrier(MPI_COMM_WORLD);
1448 if (rank == 0) {printf(
"PSEUDO-SCAN\n");}
1454 const long MM = 100;
1461 for (
int i = 0; i < 2; i++) {
1462 assert(i == 0 || i == 1);
1464 ? makemanyintegerkeys8
1465 : makemanystringkeys8);
1471 kmr_map_once(kvs0, (
void *)&MM, kmr_noopt, 0, makedatafn);
1475 kmr_map(kvs0, kvs1, 0, inspect, copynegate8);
1480 long counts[nprocs];
1485 printf(
"number of pairs on ranks:\n");
1486 for (
int r = 0; r < nprocs; r++) {
1487 printf(
"%ld", counts[r]);
1488 if (r == (nprocs - 1)) {
1490 }
else if (r == 10) {
1503 KMR_KVS *kvsvec[2] = {kvs1, kvs2};
1509 kmr_reduce(kvs4, 0, 0, kmr_noopt, comparebycanceling8);
1516 main(
int argc,
char *argv[])
1518 int nprocs, rank, thlv;
1520 MPI_Init_thread(&argc, &argv, MPI_THREAD_SERIALIZED, &thlv);
1521 MPI_Comm_size(MPI_COMM_WORLD, &nprocs);
1522 MPI_Comm_rank(MPI_COMM_WORLD, &rank);
1528 _Bool assertion = 0;
1530 _Bool assertion = 1;
1533 kmr_error(0,
"Assertion disabled; recompile this test");
1538 simple0(nprocs, rank, 0);
1539 simple0(nprocs, rank, 1);
1540 simple1(nprocs, rank);
1541 simple2(nprocs, rank);
1542 simple3(nprocs, rank);
1543 simple4(nprocs, rank);
1544 simple5(nprocs, rank);
1545 simple6(nprocs, rank);
1546 simple7(nprocs, rank);
1547 simple8(nprocs, rank);
1549 MPI_Barrier(MPI_COMM_WORLD);
1551 if (rank == 0) {printf(
"OK\n");}
Key-Value Stream (abstract).
Utilities Private Part (do not include from applications).
int kmr_map_for_some(KMR_KVS *kvi, KMR_KVS *kvo, void *arg, struct kmr_option opt, kmr_mapfn_t m)
Maps until some key-value are added.
#define kmr_reduce(KVI, KVO, ARG, OPT, R)
Reduces key-value pairs.
Options to Mapping, Shuffling, and Reduction.
int kmr_add_kv(KMR_KVS *kvs, const struct kmr_kv_box kv)
Adds a key-value pair.
KMR_KVS * kmr_create_pushoff_kvs(KMR *mr, enum kmr_kv_field kf, enum kmr_kv_field vf, struct kmr_option opt, const char *, const int, const char *)
Makes a new key-value stream with the specified field data-types.
static int kmr_icmp(const void *a0, const void *a1)
Compares the key field of keyed-records for qsort/bsearch.
int kmr_map_once(KMR_KVS *kvo, void *arg, struct kmr_option opt, _Bool rank_zero_only, kmr_mapfn_t m)
Maps once.
#define kmr_create_kvs(MR, KF, VF)
Makes a new key-value stream (of type KMR_KVS) with the specified field datatypes.
int kmr_save_kvs(KMR_KVS *kvi, void **dataq, size_t *szq, struct kmr_option opt)
Packs locally the contents of a key-value stream to a byte array.
int kmr_shuffle(KMR_KVS *kvi, KMR_KVS *kvo, struct kmr_option opt)
Shuffles key-value pairs to the appropriate destination ranks.
int kmr_distribute(KMR_KVS *kvi, KMR_KVS *kvo, _Bool cyclic, struct kmr_option opt)
Distributes key-values so that each rank has approximately the same number of pairs.
int kmr_add_kv_done(KMR_KVS *kvs)
Marks finished adding key-value pairs.
int kmr_sort_by_one(KMR_KVS *kvi, KMR_KVS *kvo, struct kmr_option opt)
Sort by rank0, a degenerated case for small number of keys.
int kmr_concatenate_kvs(KMR_KVS *kvs[], int nkvs, KMR_KVS *kvo, struct kmr_option opt)
Concatenates a number of KVSes to one.
int kmr_free_kvs(KMR_KVS *kvs)
Releases a key-value stream (type KMR_KVS).
kmr_kv_field
Datatypes of Keys or Values.
void kmr_isort(void *a, size_t n, size_t es, int depth)
Sorts by comparator on long integers.
int kmr_take_one(KMR_KVS *kvi, struct kmr_kv_box *kv)
Extracts a single key-value pair locally in the key-value stream KVI.
#define kmr_map(KVI, KVO, ARG, OPT, M)
Maps simply.
Handy Copy of a Key-Value Field.
int kmr_sort_large(KMR_KVS *kvi, KMR_KVS *kvo, struct kmr_option opt)
Sorts a key-value stream by the regular or the random sampling-sort.
int kmr_fin(void)
Clears the environment.
int kmr_get_element_count(KMR_KVS *kvs, long *v)
Gets the total number of key-value pairs.
#define kmr_init()
Sets up the environment.
void * kmr_bsearch(const void *key, const void *base, size_t nel, size_t size, int(*compar)(const void *, const void *))
Searches a key entry like bsearch(3C), but returns a next greater entry instead of null on no match...
int kmr_sort(KMR_KVS *kvi, KMR_KVS *kvo, struct kmr_option opt)
Sorts a key-value stream globally.
int kmr_assert_sorted(KMR_KVS *kvi, _Bool locally, _Bool shuffling, _Bool ranking)
Checks a key-value stream is sorted.
int kmr_shuffle_leveling_pair_count(KMR_KVS *kvi, KMR_KVS *kvo)
Shuffles key-values so that each rank has approximately the same number of pairs. ...
int kmr_histogram_count_by_ranks(KMR_KVS *kvs, long *frq, double *var, _Bool rankzeroonly)
Fills an integer array FRQ[i] with the count of the elements of each rank.
int kmr_restore_kvs(KMR_KVS *kvo, void *data, size_t sz, struct kmr_option opt)
Unpacks locally the contents of a key-value stream from a byte array.
int kmr_free_context(KMR *mr)
Releases a context created with kmr_create_context().
int kmr_load_properties(MPI_Info conf, char *filename)
Loads properties into MPI_Info (in Latin1 characters).
int kmr_replicate(KMR_KVS *kvi, KMR_KVS *kvo, struct kmr_option opt)
Replicates key-value pairs to be visible on all ranks, that is, it has the effect of bcast or all-gat...
int kmr_sort_small(KMR_KVS *kvi, KMR_KVS *kvo, struct kmr_option opt)
Sorts a key-value stream, by partitioning to equal ranges.
int kmr_sort_locally(KMR_KVS *kvi, KMR_KVS *kvo, _Bool shuffling, struct kmr_option opt)
Reorders key-value pairs in a single rank.
int(* kmr_mapfn_t)(const struct kmr_kv_box kv, const KMR_KVS *kvi, KMR_KVS *kvo, void *arg, const long index)
Map-function Type.
int kmr_map_on_rank_zero(KMR_KVS *kvo, void *arg, struct kmr_option opt, kmr_mapfn_t m)
Maps on rank0 only.
KMR * kmr_create_context(const MPI_Comm comm, const MPI_Info conf, const char *name)
Makes a new KMR context (a context has type KMR).