int eaf_ks_stat(int *data, int nvars, int npoints) { int i, j, k, l, maxd=0, d, cols; unsigned *dmap, *c, *mask; cols = (nvars - 1) / BPU + 1; dmap = calloc(npoints, cols * sizeof(unsigned)); c = calloc(cols, sizeof(unsigned)); mask = calloc(cols, sizeof(unsigned)); for (j = 0; j < cols; j++) for (k = 0; k < BPU && (l = j * BPU + k) < nvars/2; k++) mask[j] |= (1<<k); for (i = 0; i < npoints; i++) { for (j = 0; j < cols; j++) for (k = 0; k < BPU && (l = j * BPU + k) < nvars; k++) dmap[i * cols + j] |= (data[i * nvars + l]!=0) << k; } for (i = 0; i < npoints; i++) { d = 0; for (k = 0; k < cols; k++) { c[k] = dmap[i * cols + k]; d += bit_weight(c[k] & mask[k]) - bit_weight(c[k] & ~mask[k]); } if (maxd < abs(d)) maxd = abs(d); } free(dmap); free(c); free(mask); return maxd; }
int eaf2_ks_stat(int *data, int nvars, int npoints) { int i, j, k, l, maxd=0, d, cols; const int block = 8192/2; unsigned *dmap, *c, *mask; cols = (nvars - 1) / BPU + 1; dmap = calloc(npoints, cols * sizeof(unsigned)); c = calloc(cols, sizeof(unsigned)); mask = calloc(cols, sizeof(unsigned)); for (j = 0; j < cols; j++) for (k = 0; k < BPU && (l = j * BPU + k) < nvars/2; k++) mask[j] |= (1<<k); #if 0 printf("mask: %8x %8x\n",mask[1],mask[0]); printf("mask weight: %d %d\n", bit_weight(mask[1]), bit_weight(mask[0])); #endif for (i = 0; i < npoints; i++) { for (j = 0; j < cols; j++) for (k = 0; k < BPU && (l = j * BPU + k) < nvars; k++) dmap[i * cols + j] |= (data[i * nvars + l]!=0) << k; /* printf("data[%d]: %x %x\n",i, dmap[i * cols + 1], dmap[i * cols]); */ /* printf("%d\n", bit_weight(dmap[i * cols + 1])+bit_weight(dmap[i * cols]));*/ } for (l = 0; l < npoints; l += block) { /* printf("l = %d\n", l);*/ for (i = l; i < npoints; i++) { for (j = l; j < (l + block) && j <= i; j++) { d = 0; for (k = 0; k < cols; k++) { c[k] = dmap[i * cols + k] & dmap[j * cols + k]; d += bit_weight(c[k] & mask[k]) - bit_weight(c[k] & ~mask[k]); } if (maxd < abs(d)) maxd = abs(d); } } } free(dmap); free(c); free(mask); return maxd; }
static void process_smpl_buf(int id, unsigned long smpl_pmd_mask, int need_restart) { static unsigned long last_overflow = ~0UL; /* initialize to biggest value possible */ smpl_hdr_t *hdr = (smpl_hdr_t *)buf_addr; smpl_entry_t *ent; unsigned long count, entry, *reg, pos, msk; unsigned long entry_size; int j; printf("processing %s buffer at %p\n", need_restart==0 ? "leftover" : "", hdr); if (hdr->hdr_overflows <= last_overflow && last_overflow != ~0UL) { warning("skipping identical set of samples %lu <= %lu\n", hdr->hdr_overflows, last_overflow); return; } last_overflow = hdr->hdr_overflows; count = hdr->hdr_count; ent = (smpl_entry_t *)(hdr+1); pos = (unsigned long)ent; entry = collect_samples; /* * in this example program, we use fixed-size entries, therefore we * can compute the entry size in advance. Perfmon-2 supports variable * size entries. */ entry_size = sizeof(smpl_entry_t)+(bit_weight(smpl_pmd_mask)<<3); while(count--) { printf("entry %ld PID:%d CPU:%d IIP:0x%016lx\n", entry, ent->pid, ent->cpu, ent->ip); printf("\tOVFL: %d LAST_VAL: %lu\n", ent->ovfl_pmd, -ent->last_reset_val); /* * print body: additional PMDs recorded * PMD are recorded in increasing index order */ reg = (unsigned long *)(ent+1); for(j=0, msk = smpl_pmd_mask; msk; msk >>=1, j++) { if ((msk & 0x1) == 0) continue; printf("PMD%-2d = 0x%016lx\n", j, *reg); reg++; } /* * we could have removed this and used: * ent = (smpl_entry_t *)reg * instead. */ pos += entry_size; ent = (smpl_entry_t *)pos; entry++; } collect_samples = entry; /* * reactivate monitoring once we are done with the samples * * Note that this call can fail with EBUSY in non-blocking mode * as the task may have disappeared while we were processing * the samples. */ if (need_restart && perfmonctl(id, PFM_RESTART, 0, 0) == -1) { if (errno != EBUSY) fatal_error("perfmonctl error PFM_RESTART errno %d\n",errno); else warning("PFM_RESTART: task has probably terminated \n"); } }
int *eaf2_ks_tail(int *data, int nvars, int npoints, double alpha, int nperms) { int i, j, k, l; int n; int w, *D, *tail, critv, ncrit, a, d; unsigned *dmap, *x, *p; #if 0 long long int visited = 0; #endif const int cols = (nvars - 1) / BPU + 1; const int jblock = 4096 /* XBLOCK / (sizeof(unsigned) * cols)*/; /* assume two samples of equal size */ if (nvars % 2) { fprintf(stderr,"ERROR: Sample size must be positive and even\n"); fprintf(stderr," (assuming two independent samples of equal size)\n"); return NULL; } /* number of permutations must be positive */ if (nperms <= 0) { fprintf(stderr,"ERROR: Number of permutations must be positive\n"); return NULL; } /* Attainment data is stored in an array of bitmaps */ dmap = calloc(npoints, cols * sizeof(unsigned)); /* Temporary bitmap */ x = calloc(cols, sizeof(unsigned)); /* Absolute distance between EAFs per permutation */ D = calloc(nperms, sizeof(*D)); /* Null distribution histogram */ tail = malloc(1+nvars/2 * sizeof(*tail)); tail[0] = nperms; for (i = 1; i <= nvars/2; tail[i++] = 0); critv = 0; ncrit = 0; /* Convert significance level to no. of permutations */ a = alpha * nperms; /* Create random mask */ p = randmask(nperms, nvars, nvars/2); /* Store data into dmap */ for (i = 0; i < npoints; i++) { for (j = 0; j < cols; j++) for (k = 0; k < BPU && (l = j * BPU + k) < nvars; k++) dmap[i * cols + j] |= (data[i * nvars + l]!=0) << k; } for (l = 0; l < npoints; l += jblock) { for (i = l; i < npoints; i++) { for (j = l; j < (l + jblock) && j <= i; j++) { w = 0; for (k = 0; k < cols; k++) { x[k] = (dmap[i * cols + k] & dmap[j * cols + k]); w += bit_weight(x[k]); } if (w <= critv || (nvars - w) <= critv) continue; #if 0 visited++; #endif for (n = 0; n < nperms; n++) if (w > D[n] && (nvars - w) > D[n]) { d = 0; for (k = 0; k < cols; k++) d += bit_weight(x[k] & p[n*cols+k]) - bit_weight(x[k] & ~p[n*cols+k]); if (D[n] < abs(d)) { tail[D[n]]--; tail[abs(d)]++; if (D[n] <= critv && abs(d) > critv) { ncrit++; while (ncrit > a) ncrit -= tail[++critv]; #if 0 fprintf(stderr, "critv = %d, ncrit = %d\n", critv, ncrit); fflush(stderr); #endif } D[n] = abs(d); } } } } } free(dmap); free(p); free(x); free(D); tail[0] = critv; for (i = 1; i <= critv; tail[i++]=0); return tail; }