int main(void)
{
int i;
memset(A, 3, sizeof(A));
if (!put(0, DET_START | DET_SNAP, 0, 0, 0)) {
//memset(A, 4, sizeof(A));
dret();
}
get(0,0,0,0,0);
long t=bench_time();
get(0, DET_MERGE, (long)A, SZ, 0);
t=bench_time()-t;
printf("Took %ld.%09ld\n",
t/1000000000,
t%1000000000);
return 0;
}
int main(int argc, char **argv)
{
int counter = 0;
int dim, nth, nbi, nbj, iter;
if (3 != argc)
usage(argv);
nbi = strtol(argv[1], NULL, 0);
nbj = strtol(argv[2], NULL, 0);
if (nbi <= 0 || nbj <= 0)
usage(argv);
int niter = 10;
for (dim = MINDIM; dim <= MAXDIM; dim *= 2) {
nth = nbi * nbj;
/* Once to warm up. */
genmatrix(counter++);
matmult(nbi, nbj, dim);
printf("matrix size: %dx%d = %d (%d bytes) ",
dim, dim, dim*dim, dim*dim*(int)sizeof(elt));
printf("blksize %dx%d thr %d itr %d:\n",
dim/nbi, dim/nbj, nth, niter);
for (iter = 0; iter < niter; iter++) {
genmatrix(counter++);
uint64_t ts = bench_time();
matmult(nbi, nbj, dim);
ts = bench_time() - ts;
printf("%lld.%09lld\n",
(long long)ts / 1000000000,
(long long)ts % 1000000000);
}
}
return 0;
}
int main1(int argc, char **argv)
{
int nbi = 4;
int nbj = 4;
int nth = nbi * nbj;
int dim = 1024;
/* Block size = 256x256 */
int i;
int niter = 10;
uint64_t tt = 0;
for (i = 0; i < niter; ++i) {
genmatrix(i);
uint64_t ts = bench_time();
matmult(nbi, nbj, dim);
tt += bench_time() - ts;
}
tt /= niter;
printf("blksize %dx%d thr %d itr %d: %lld.%09lld\n",
dim/nbi, dim/nbj, nth, niter,
(long long)tt / 1000000000,
(long long)tt % 1000000000);
return 0;
}
int main(int argc, char **argv)
{
int nth, nbi, nbj, iter;
int counter = 0;
if (3 != argc)
usage(argv);
nbi = strtol(argv[1], NULL, 0);
nbj = strtol(argv[2], NULL, 0);
if (nbi <= 0 || nbj <= 0)
usage(argv);
nth = nbi * nbj;
int niter = 10;
for (n = MINDIM; n <= MAXDIM; n *= 2) {
printf("matrix size: %dx%d = %d (%d bytes) ",
n, n, n*n, n*n*(int)sizeof(mtype));
printf("blksize %dx%d thr %4d itr %d:\n",
n/nbi, n/nbj, nth, niter);
for (iter = 0; iter < niter; iter++) {
genmatrix(counter++);
uint64_t ts = bench_time();
plu(nbi, nbj);
ts = bench_time() - ts;
printf("%lld.%09lld\n",
(long long)ts / 1000000000,
(long long)ts % 1000000000);
#if CHECK_CORRECTNESS
matmult();
check(Orig, R);
#endif
}
}
return 0;
}
int main(int argc, char **argv)
{
int i;
for (i = 0; i < MAXDIM*MAXDIM; i++)
a[i] = b[i] = i;
int dim, nth, nbi, nbj, iter;
for (dim = MINDIM; dim <= MAXDIM; dim *= 2) {
printf("matrix size: %dx%d = %d (%d bytes)\n",
dim, dim, dim*dim, dim*dim*(int)sizeof(elt));
for (nth = nbi = nbj = 1; nth <= MAXTHREADS; ) {
assert(nth == nbi * nbj);
int niter = MAXDIM/dim;
niter = niter * niter; // * niter; // MM = O(n^3)
matmult(nbi, nbj, dim); // once to warm up...
uint64_t ts = bench_time();
for (iter = 0; iter < niter; iter++)
matmult(nbi, nbj, dim);
uint64_t td = (bench_time() - ts) / niter;
printf("blksize %dx%d thr %d itr %d: %lld.%09lld\n",
dim/nbi, dim/nbj, nth, niter,
(long long)td / 1000000000,
(long long)td % 1000000000);
if (nbi == nbj)
nbi *= 2;
else
nbj *= 2;
nth *= 2;
}
}
return 0;
}
int main(int argc, char **argv)
{
int full, np, nth, i, j, val = 0;
struct args a;
forktest(); // once to warm up
const int forkiters = 10000;
uint64_t ts = bench_time();
for (i = 0; i < forkiters; i++)
forktest();
uint64_t td = (bench_time() - ts) / forkiters;
printf("proc fork/wait: %lld ns\n", (long long)td);
for (full = 0; full < 2; full++) {
for (np = 1; np <= 1024; np *= 2) {
for (nth = 1; nth <= MAXTHREADS; nth *= 2) {
a.npages = np;
a.fullpage = full;
a.nthreads = nth;
a.val = val++;
writetest(&a); // once to warm up
const int iters = 10000;
ts = bench_time();
for (j = 0; j < iters; j++)
writetest(&a);
td = (bench_time() - ts) / iters;
printf("fork/join x%d, %s %d pages: %lld ns\n",
nth,
full ? "scrubbing" : "touching", np,
(long long)td);
}
}
}
return 0;
}
