main(int argc, char *argv[])
{
int streamnum, commNum, nstreams, *stream, *commonStream;
double rn;
int i, myid, nprocs;
/************************** MPI calls ***********************************/
MPI_Init(&argc, &argv); /* Initialize MPI */
MPI_Comm_rank(MPI_COMM_WORLD, &myid); /* find process id */
MPI_Comm_size(MPI_COMM_WORLD, &nprocs); /* find number of processes */
/****************** Initialization values *******************************/
streamnum = myid; /*This stream is different on each process*/
commNum = nprocs; /* This stream is common to all processes */
nstreams = nprocs + 1; /* extra stream is common to all processes*/
/*********************** Initialize streams *****************************/
/* This stream is different on each process */
stream = init_sprng(streamnum,nstreams,SEED,SPRNG_DEFAULT);
printf("Process %d: Print information about new stream\n", myid);
print_sprng(stream);
/* This stream is identical on each process */
commonStream = init_sprng(commNum,nstreams,SEED,SPRNG_DEFAULT);
printf("Process %d: This stream is identical on all processes\n", myid);
print_sprng(commonStream);
/*********************** print random numbers ***************************/
for (i=0;i<2;i++) /* random numbers from distinct stream */
{
rn = sprng(stream); /* generate double precision random number*/
printf("Process %d, random number (distinct stream) %d: %f\n",
myid, i+1, rn);
}
for (i=0;i<2;i++) /* random number from common stream */
{
rn = sprng(commonStream); /*generate double precision random number */
printf("Process %d, random number (shared stream) %d: %f\n", myid, i+1, rn);
}
/*************************** free memory ********************************/
free_sprng(stream); /* free memory used to store stream state */
free_sprng(commonStream);
MPI_Finalize(); /* terminate MPI */
}
PetscErrorCode PETSC_DLLEXPORT PetscRandomGetValueReal_Sprng(PetscRandom r,PetscScalar *val)
{
PetscFunctionBegin;
#if defined(PETSC_USE_COMPLEX)
if (r->iset) *val = PetscRealPart(r->width)*sprng() + PetscRealPart(r->low);
else *val = sprng();
#else
if (r->iset) *val = r->width * sprng() + r->low;
else *val = sprng();
#endif
PetscFunctionReturn(0);
}
PetscErrorCode PetscRandomGetValue_Sprng(PetscRandom r,PetscScalar *val)
{
PetscFunctionBegin;
#if defined(PETSC_USE_COMPLEX)
if (r->iset) {
*val = PetscRealPart(r->width)*sprng() + PetscRealPart(r->low) + (PetscImaginaryPart(r->width)*sprng() + PetscImaginaryPart(r->low)) * PETSC_i;
} else {
*val = sprng() + sprng()*PETSC_i;
}
#else
if (r->iset) *val = r->width * sprng() + r->low;
else *val = sprng();
#endif
PetscFunctionReturn(0);
}
void FFTCalc(int nstreams, int nruns, int n)
{
int i,j,k;
double *coeff;
for(k=0; k<nruns; k++) /* Repeat calculation 'nruns' times */
{
for (j=0; j<nstreams; j++) /* fill array with random numbers */
for (i=0; i<n; i++)
FFTcoeffs[i+j*lda] = sprng(streams[j]);
coeff = dzfft2dui (n, nstreams, NULL); /*initialize FFT modules */
dzfft2du(1,n,nstreams,FFTcoeffs,lda, coeff); /* Compute FFT in place */
for (i=0; i<lda*nstreams; i++) /* Compute mean for each coefficient */
means[i] += FFTcoeffs[i];
#ifdef DEBUG /* Check if inverse transform yields original data */
zdfft2du (-1, n, nstreams, FFTcoeffs, lda, coeff);
dscal2d(n,nstreams,1.0/(double)(n*nstreams),FFTCoeffs,lda);
for(i=0; i<(lda*nstreams); i++)
printf("array[%d] = %g\n", i, FFTcoeffs[i]);
#endif
} /*end loop for nruns */
for (i=0; i<lda*nstreams; i++) /* Compute mean for each coefficient */
means[i] /= nruns;
return;
}
main()
{
int streamnum, nstreams, seed, *stream, i;
double rn;
/************************** Initialization *******************************/
streamnum = 0;
nstreams = 1;
seed = make_sprng_seed(); /* make new seed each time program is run */
stream = init_sprng(streamnum,nstreams,seed,SPRNG_DEFAULT); /*initialize stream*/
printf(" Printing information about new stream\n");
print_sprng(stream);
/************************ print random numbers ***************************/
printf(" Printing 3 random numbers in [0,1):\n");
for (i=0;i<3;i++)
{
rn = sprng(stream); /* generate double precision random number */
printf("%f\n", rn);
}
free_sprng(stream); /* free memory used to store stream state */
}
main()
{
int streamnum, nstreams, *stream, **new;
double rn;
int i, irn, nspawned;
int gtype; /*--- */
/*--- reading in a generator type */
#include "gen_types_menu.h"
printf("Type in a generator type (integers: 0,1,2,3,4,5): ");
scanf("%d", >ype);
/****************** Initialization values *******************************/
streamnum = 0;
nstreams = 1;
stream = init_sprng(gtype,streamnum,nstreams,SEED,SPRNG_DEFAULT); /* initialize stream */
printf(" Print information about stream:\n");
print_sprng(stream);
/*********************** print random numbers ***************************/
printf(" Printing 2 random numbers in [0,1):\n");
for (i=0;i<2;i++)
{
rn = sprng(stream); /* generate double precision random number*/
printf("%f\n", rn);
}
/**************************** spawn streams *****************************/
printf(" Spawned two streams\n");
nspawned = 2;
nspawned = spawn_sprng(stream,2,&new); /* spawn 2 streams */
if(nspawned != 2)
{
fprintf(stderr,"Error: only %d streams spawned\n", nspawned);
exit(1);
}
printf(" Information on first spawned stream:\n");
print_sprng(new[0]);
printf(" Information on second spawned stream:\n");
print_sprng(new[1]);
printf(" Printing 2 random numbers from second spawned stream:\n");
for (i=0;i<2;i++)
{
rn = sprng(new[1]); /* generate a random number */
printf("%f\n", rn);
}
/*************************** free memory ********************************/
free_sprng(stream); /* free memory used to store stream state */
free_sprng(new[0]); /* free memory used to store stream state */
free_sprng(new[1]); /* free memory used to store stream state */
free(new);
}
inline int random(const int lower, const int upper) {
if (lower == upper) {
return lower;
}
#ifdef USE_SPRNG
return static_cast<int>(sprng() * (upper - lower) + lower);
#else
return static_cast<int>(drand48() * (upper - lower) + lower);
#endif
}
void Single_Cluster_Update(void) /* update lattice spins: a single sweep */
{
static int nSite[4], Ipt=-1;
int i, j, nnJ, ix, iy;
double ff;
i = RNG()>>(31-(exponent<<1));
if(i<0)
i += nsites;
spin[i] = -spin[i];
while(i >= 0)
{
/* ix=I/size; iy=I%size; */
ix =i>>exponent; iy=i&mask;
/* printf("ix=%d, iy=%d) ", ix, iy); */
if(iy==0) nSite[0]=(ix<<exponent)+mask; /* nSite[0]=ix*size+size-1; */
else nSite[0]=i-1;
if(iy==lattice_size-1) nSite[2]=ix<<exponent; /* nSite[2]=ix*size; */
else nSite[2]=i+1;
if(ix==0) nSite[1]=(mask<<exponent)+iy; /* nSite[1]=(size-1)*size+iy; */
else nSite[1]=i-lattice_size;
if(ix==lattice_size-1) nSite[3]=iy;
else nSite[3]=i+lattice_size;
for(j=0; j<4; j++)
{
nnJ=nSite[j];
if(spin[i]==spin[nnJ])
continue;
/* notice prog should be scaled to MAXIMUM if necessary */
if(sprng(genptr[i])>prob)
continue;
spin[nnJ]=-spin[nnJ];
stack[++Ipt]=nnJ;
}
if(Ipt>=0)
{
i=stack[Ipt];
Ipt--;
}
else i=-1;
}
}
main(int argc, char *argv[])
{
int streamnum, nstreams, seed, *stream, i, myid, nprocs;
double rn;
int gtype; /*--- */
/*************************** MPI calls ***********************************/
MPI_Init(&argc, &argv); /* Initialize MPI */
MPI_Comm_rank(MPI_COMM_WORLD, &myid); /* find process id */
MPI_Comm_size(MPI_COMM_WORLD, &nprocs); /* find number of processes */
/************************** Initialization *******************************/
streamnum = myid;
nstreams = nprocs; /* one stream per processor */
seed = make_sprng_seed(); /* make new seed each time program is run */
/*--- node 0 is reading in a generator type */
if(myid == 0)
{
#include "gen_types_menu.h"
printf("Type in a generator type (integers: 0,1,2,3,4,5): ");
scanf("%d", >ype);
}
MPI_Bcast(>ype,1,MPI_INT,0,MPI_COMM_WORLD );
/* Seed should be the same on all processes */
printf("Process %d: seed = %16d\n", myid, seed);
stream = init_sprng(gtype,streamnum,nstreams,seed,SPRNG_DEFAULT); /*initialize stream*/
printf("\n\nProcess %d: Print information about stream:\n",myid);
print_sprng(stream);
/************************ print random numbers ***************************/
for (i=0;i<3;i++)
{
rn = sprng(stream); /* generate double precision random number */
printf("process %d, random number %d: %f\n", myid, i+1, rn);
}
free_sprng(stream); /* free memory used to store stream state */
MPI_Finalize(); /* Terminate MPI */
}
void reinit(const double sampleRate, const uint32_t bufferSize)
{
Master::deleteInstance();
if (denormalkillbuf != nullptr)
{
delete[] denormalkillbuf;
denormalkillbuf = nullptr;
}
if (synth != nullptr)
{
delete synth;
synth = nullptr;
}
synth = new SYNTH_T();
synth->buffersize = bufferSize;
synth->samplerate = sampleRate;
if (synth->buffersize > 32)
synth->buffersize = 32;
synth->alias();
config.init();
config.cfg.SoundBufferSize = synth->buffersize;
config.cfg.SampleRate = synth->samplerate;
config.cfg.GzipCompression = 0;
config.cfg.UserInterfaceMode = 1;
sprng((std::time(nullptr)));
denormalkillbuf = new float[synth->buffersize];
for (int i=0; i < synth->buffersize; ++i)
denormalkillbuf[i] = (RND - 0.5f) * 1e-16f;
Master::getInstance();
}
main(int argc, char *argv[])
{
int streamnum, nstreams, *stream;
double rn;
int i, myid, nprocs;
/*************************** MPI calls ***********************************/
MPI_Init(&argc, &argv); /* Initialize MPI */
MPI_Comm_rank(MPI_COMM_WORLD, &myid); /* find process id */
MPI_Comm_size(MPI_COMM_WORLD, &nprocs); /* find number of processes */
/************************** Initialization *******************************/
streamnum = myid;
nstreams = nprocs; /* one stream per processor */
stream = init_sprng(streamnum,nstreams,SEED,SPRNG_DEFAULT); /* initialize stream */
printf("Process %d, print information about stream:\n", myid);
print_sprng(stream);
/*********************** print random numbers ****************************/
for (i=0;i<3;i++)
{
rn = sprng(stream); /* generate double precision random number */
printf("Process %d, random number %d: %.14f\n", myid, i+1, rn);
}
/*************************** free memory *********************************/
free_sprng(stream); /* free memory used to store stream state */
MPI_Finalize(); /* Terminate MPI */
}
main(int argc, char *argv[])
{
double rn;
int i, myid;
int gtype; /*--- */
/*************************** MPI calls ***********************************/
MPI_Init(&argc, &argv); /* Initialize MPI */
MPI_Comm_rank(MPI_COMM_WORLD, &myid); /* find process id */
/************************** Initialization *******************************/
/*--- node 0 is reading in a generator type */
if(myid == 0)
{
#include "gen_types_menu.h"
printf("Type in a generator type (integers: 0,1,2,3,4,5): ");
scanf("%d", >ype);
}
MPI_Bcast(>ype,1,MPI_INT,0,MPI_COMM_WORLD );
init_sprng(gtype,SEED,SPRNG_DEFAULT); /* initialize stream */
printf("\n\nProcess %d, print information about stream:\n", myid);
print_sprng();
/************************ print random numbers ***************************/
for (i=0;i<3;i++)
{
rn = sprng(); /* generate double precision random number */
printf("Process %d, random number %d: %.14f\n", myid, i+1, rn);
}
MPI_Finalize(); /* Terminate MPI */
}
main(int argc, char *argv[])
{
int i, size;
double rn;
FILE *fp;
char buffer[MAX_PACKED_LENGTH], outfile[80], infile[80], *bytes;
int gtype; /*--- */
/*--- reading in a generator type */
#include "gen_types_menu.h"
printf("Type in a generator type (integers: 0,1,2,3,4,5): ");
scanf("%d", >ype);
/*********************** Initialize streams *******************************/
printf("Enter name of file to store final state of the stream:\n");
scanf("%s", outfile);
printf("Enter name of file to read from:\n\t(enter 9 for a new run)\n");
scanf("%s", infile);
if(infile[0] == '9') /* initialize stream the first time */
init_sprng(gtype,SEED,SPRNG_DEFAULT);
else /* read stream state from file afterwards */
{
fp = fopen(infile,"r");
if(fp == NULL)
{
fprintf(stderr,"Could not open file %s for reading\nCheck path or permissions\n", infile);
exit(1);
}
fread(&size,1,sizeof(int),fp);
fread(buffer,1,size,fp);
unpack_sprng(buffer);
fclose(fp);
}
/*********************** print random numbers *****************************/
printf(" Printing 5 random numbers in [0,1): \n");
for(i=0; i<5; i++)
{
rn = sprng(); /* generate a double precision random number */
printf("%d %f\n", i+1, rn);
}
/************************* store stream state *****************************/
size = pack_sprng(&bytes); /* pack stream state into an array */
fp = fopen(outfile,"w"); /* open file to store stream state */
if(fp == NULL)
{
fprintf(stderr,"Could not open file %s for writing\nCheck path or permissions\n", outfile);
exit(1);
}
fwrite(&size,1,sizeof(int),fp); /* store # of bytes required for storage */
fwrite(bytes,1,size,fp); /* store stream state */
fclose(fp);
free(bytes); /* free memory needed to store stream state */
}
void vertex_betweenness_centrality_parBFS(graph_t* G, double* BC, long numSrcs) {
attr_id_t *S; /* stack of vertices in the order of non-decreasing
distance from s. Also used to implicitly
represent the BFS queue */
plist_t* P; /* predecessors of a vertex v on shortest paths from s */
double* sig; /* No. of shortest paths */
attr_id_t* d; /* Length of the shortest path between every pair */
double* del; /* dependency of vertices */
attr_id_t *in_degree, *numEdges, *pSums;
attr_id_t* pListMem;
#if RANDSRCS
attr_id_t* Srcs;
#endif
attr_id_t *start, *end;
long MAX_NUM_PHASES;
attr_id_t *psCount;
#ifdef _OPENMP
omp_lock_t* vLock;
long chunkSize;
#endif
#ifdef DIAGNOSTIC
double elapsed_time;
#endif
int seed = 2387;
#ifdef _OPENMP
#pragma omp parallel firstprivate(G)
{
#endif
attr_id_t *myS, *myS_t;
attr_id_t myS_size;
long i, j, k, p, count, myCount;
long v, w, vert;
long k0, k1;
long numV, num_traversals, n, m, phase_num;
long start_iter, end_iter;
long tid, nthreads;
int* stream;
#ifdef DIAGNOSTIC
double elapsed_time_part;
#endif
#ifdef _OPENMP
int myLock;
tid = omp_get_thread_num();
nthreads = omp_get_num_threads();
#else
tid = 0;
nthreads = 1;
#endif
#ifdef DIAGNOSTIC
if (tid == 0) {
elapsed_time = get_seconds();
elapsed_time_part = get_seconds();
}
#endif
/* numV: no. of vertices to run BFS from = numSrcs */
numV = numSrcs;
n = G->n;
m = G->m;
/* Permute vertices */
if (tid == 0) {
#if RANDSRCS
Srcs = (attr_id_t *) malloc(n*sizeof(attr_id_t));
#endif
#ifdef _OPENMP
vLock = (omp_lock_t *) malloc(n*sizeof(omp_lock_t));
#endif
}
#ifdef _OPENMP
#pragma omp barrier
#pragma omp for
for (i=0; i<n; i++) {
omp_init_lock(&vLock[i]);
}
#endif
/* Initialize RNG stream */
stream = init_sprng(0, tid, nthreads, seed, SPRNG_DEFAULT);
#if RANDSRCS
#ifdef _OPENMP
#pragma omp for
#endif
for (i=0; i<n; i++) {
Srcs[i] = i;
}
#ifdef _OPENMP
#pragma omp for
#endif
for (i=0; i<n; i++) {
j = n * sprng(stream);
if (i != j) {
#ifdef _OPENMP
int l1 = omp_test_lock(&vLock[i]);
if (l1) {
int l2 = omp_test_lock(&vLock[j]);
if (l2) {
#endif
k = Srcs[i];
Srcs[i] = Srcs[j];
Srcs[j] = k;
#ifdef _OPENMP
omp_unset_lock(&vLock[j]);
}
omp_unset_lock(&vLock[i]);
}
#endif
}
}
#endif
#ifdef _OPENMP
#pragma omp barrier
#endif
if (tid == 0) {
MAX_NUM_PHASES = 500;
}
#ifdef _OPENMP
#pragma omp barrier
#endif
/* Initialize predecessor lists */
/* The size of the predecessor list of each vertex is bounded by
its in-degree. So we first compute the in-degree of every
vertex */
if (tid == 0) {
P = (plist_t *) calloc(n, sizeof(plist_t));
in_degree = (attr_id_t *) calloc(n+1, sizeof(attr_id_t));
numEdges = (attr_id_t *) malloc((n+1)*sizeof(attr_id_t));
pSums = (attr_id_t *) malloc(nthreads*sizeof(attr_id_t));
}
#ifdef _OPENMP
#pragma omp barrier
#pragma omp for
#endif
for (i=0; i<m; i++) {
v = G->endV[i];
#ifdef _OPENMP
omp_set_lock(&vLock[v]);
#endif
in_degree[v]++;
#ifdef _OPENMP
omp_unset_lock(&vLock[v]);
#endif
}
prefix_sums(in_degree, numEdges, pSums, n);
if (tid == 0) {
pListMem = (attr_id_t *) malloc(m*sizeof(attr_id_t));
}
#ifdef _OPENMP
#pragma omp barrier
#pragma omp for
#endif
for (i=0; i<n; i++) {
P[i].list = pListMem + numEdges[i];
P[i].degree = in_degree[i];
P[i].count = 0;
}
#ifdef DIAGNOSTIC
if (tid == 0) {
elapsed_time_part = get_seconds() -elapsed_time_part;
fprintf(stderr, "In-degree computation time: %lf seconds\n",
elapsed_time_part);
elapsed_time_part = get_seconds();
}
#endif
/* Allocate shared memory */
if (tid == 0) {
free(in_degree);
free(numEdges);
free(pSums);
S = (attr_id_t *) malloc(n*sizeof(attr_id_t));
sig = (double *) malloc(n*sizeof(double));
d = (attr_id_t *) malloc(n*sizeof(attr_id_t));
del = (double *) calloc(n, sizeof(double));
start = (attr_id_t *) malloc(MAX_NUM_PHASES*sizeof(attr_id_t));
end = (attr_id_t *) malloc(MAX_NUM_PHASES*sizeof(attr_id_t));
psCount = (attr_id_t *) malloc((nthreads+1)*sizeof(attr_id_t));
}
/* local memory for each thread */
myS_size = (2*n)/nthreads;
myS = (attr_id_t *) malloc(myS_size*sizeof(attr_id_t));
num_traversals = 0;
myCount = 0;
#ifdef _OPENMP
#pragma omp barrier
#endif
#ifdef _OPENMP
#pragma omp for
#endif
for (i=0; i<n; i++) {
d[i] = -1;
}
#ifdef DIAGNOSTIC
if (tid == 0) {
elapsed_time_part = get_seconds() - elapsed_time_part;
fprintf(stderr, "BC initialization time: %lf seconds\n",
elapsed_time_part);
elapsed_time_part = get_seconds();
}
#endif
for (p=0; p<n; p++) {
#if RANDSRCS
i = Srcs[p];
#else
i = p;
#endif
if (G->numEdges[i+1] - G->numEdges[i] == 0) {
continue;
} else {
num_traversals++;
}
if (num_traversals == numV + 1) {
break;
}
if (tid == 0) {
sig[i] = 1;
d[i] = 0;
S[0] = i;
start[0] = 0;
end[0] = 1;
}
count = 1;
phase_num = 0;
#ifdef _OPENMP
#pragma omp barrier
#endif
while (end[phase_num] - start[phase_num] > 0) {
myCount = 0;
start_iter = start[phase_num];
end_iter = end[phase_num];
#ifdef _OPENMP
#pragma omp barrier
#pragma omp for schedule(dynamic) nowait
#endif
for (vert = start_iter; vert < end_iter; vert++) {
v = S[vert];
for (j=G->numEdges[v]; j<G->numEdges[v+1]; j++) {
w = G->endV[j];
if (v != w) {
#ifdef _OPENMP
myLock = omp_test_lock(&vLock[w]);
if (myLock) {
#endif
/* w found for the first time? */
if (d[w] == -1) {
if (myS_size == myCount) {
/* Resize myS */
myS_t = (attr_id_t *)
malloc(2*myS_size*sizeof(attr_id_t));
memcpy(myS_t, myS,
myS_size*sizeof(attr_id_t));
free(myS);
myS = myS_t;
myS_size = 2*myS_size;
}
myS[myCount++] = w;
d[w] = d[v] + 1;
sig[w] = sig[v];
P[w].list[P[w].count++] = v;
} else if (d[w] == d[v] + 1) {
sig[w] += sig[v];
P[w].list[P[w].count++] = v;
}
#ifdef _OPENMP
omp_unset_lock(&vLock[w]);
} else {
if ((d[w] == -1) || (d[w] == d[v]+ 1)) {
omp_set_lock(&vLock[w]);
sig[w] += sig[v];
P[w].list[P[w].count++] = v;
omp_unset_lock(&vLock[w]);
}
}
#endif
}
}
}
/* Merge all local stacks for next iteration */
phase_num++;
if (tid == 0) {
if (phase_num >= MAX_NUM_PHASES) {
fprintf(stderr, "Error: Max num phases set to %ld\n",
MAX_NUM_PHASES);
fprintf(stderr, "Diameter of input network greater than"
" this value. Increase MAX_NUM_PHASES"
" in vertex_betweenness_centrality_parBFS()\n");
exit(-1);
}
}
psCount[tid+1] = myCount;
#ifdef _OPENMP
#pragma omp barrier
#endif
if (tid == 0) {
start[phase_num] = end[phase_num-1];
psCount[0] = start[phase_num];
for(k=1; k<=nthreads; k++) {
psCount[k] = psCount[k-1] + psCount[k];
}
end[phase_num] = psCount[nthreads];
}
#ifdef _OPENMP
#pragma omp barrier
#endif
k0 = psCount[tid];
k1 = psCount[tid+1];
for (k = k0; k < k1; k++) {
S[k] = myS[k-k0];
}
count = end[phase_num];
}
phase_num--;
while (phase_num > 0) {
start_iter = start[phase_num];
end_iter = end[phase_num];
#ifdef _OPENMP
#pragma omp for schedule(static) nowait
#endif
for (j=start_iter; j<end_iter; j++) {
w = S[j];
for (k = 0; k<P[w].count; k++) {
v = P[w].list[k];
#ifdef _OPENMP
omp_set_lock(&vLock[v]);
#endif
del[v] = del[v] + sig[v]*(1+del[w])/sig[w];
#ifdef _OPENMP
omp_unset_lock(&vLock[v]);
#endif
}
BC[w] += del[w];
}
phase_num--;
#ifdef _OPENMP
#pragma omp barrier
#endif
}
#ifdef _OPENMP
chunkSize = n/nthreads;
#pragma omp for schedule(static, chunkSize) nowait
#endif
for (j=0; j<count; j++) {
w = S[j];
d[w] = -1;
del[w] = 0;
P[w].count = 0;
}
#ifdef _OPENMP
#pragma omp barrier
#endif
}
#ifdef DIAGNOSTIC
if (tid == 0) {
elapsed_time_part = get_seconds() - elapsed_time_part;
fprintf(stderr, "BC computation time: %lf seconds\n",
elapsed_time_part);
}
#endif
#ifdef _OPENMP
#pragma omp barrier
#endif
#ifdef _OPENMP
#pragma omp for
for (i=0; i<n; i++) {
omp_destroy_lock(&vLock[i]);
}
#endif
free(myS);
if (tid == 0) {
free(S);
free(pListMem);
free(P);
free(sig);
free(d);
free(del);
#ifdef _OPENMP
free(vLock);
#endif
free(start);
free(end);
free(psCount);
#ifdef DIAGNOSTIC
elapsed_time = get_seconds() - elapsed_time;
fprintf(stderr, "Time taken: %lf\n seconds", elapsed_time);
#endif
#if RANDSRCS
free(Srcs);
#endif
}
free_sprng(stream);
#ifdef _OPENMP
}
#endif
}
void vertex_betweenness_centrality_simple(graph_t* G, double* BC, long numSrcs) {
attr_id_t *in_degree, *numEdges, *pSums;
#if RANDSRCS
attr_id_t* Srcs;
#endif
long num_traversals = 0;
#ifdef _OPENMP
omp_lock_t* vLock;
long chunkSize;
#endif
#ifdef DIAGNOSTIC
double elapsed_time;
#endif
int seed = 2387;
/* The outer loop is parallelized in this case. Each thread does a BFS
and the vertex BC values are incremented atomically */
#ifdef _OPENMP
#pragma omp parallel firstprivate(G)
{
#endif
attr_id_t *S; /* stack of vertices in the order of non-decreasing
distance from s. Also used to implicitly
represent the BFS queue */
plist_t* P; /* predecessors of a vertex v on shortest paths
from s */
attr_id_t* pListMem;
double* sig; /* No. of shortest paths */
attr_id_t* d; /* Length of the shortest path between every pair */
double* del; /* dependency of vertices */
attr_id_t *start, *end;
long MAX_NUM_PHASES;
long i, j, k, p, count;
long v, w, vert;
long numV, n, m, phase_num;
long tid, nthreads;
int* stream;
#ifdef DIAGNOSTIC
double elapsed_time_part;
#endif
#ifdef _OPENMP
int myLock;
tid = omp_get_thread_num();
nthreads = omp_get_num_threads();
#else
tid = 0;
nthreads = 1;
#endif
#ifdef DIAGNOSTIC
if (tid == 0) {
elapsed_time = get_seconds();
elapsed_time_part = get_seconds();
}
#endif
/* numV: no. of vertices to run BFS from = numSrcs */
numV = numSrcs;
n = G->n;
m = G->m;
/* Permute vertices */
if (tid == 0) {
#if RANDSRCS
Srcs = (attr_id_t *) malloc(n*sizeof(attr_id_t));
#endif
#ifdef _OPENMP
vLock = (omp_lock_t *) malloc(n*sizeof(omp_lock_t));
#endif
}
#ifdef _OPENMP
#pragma omp barrier
#pragma omp for
for (i=0; i<n; i++) {
omp_init_lock(&vLock[i]);
}
#endif
/* Initialize RNG stream */
stream = init_sprng(0, tid, nthreads, seed, SPRNG_DEFAULT);
#if RANDSRCS
#ifdef _OPENMP
#pragma omp for
#endif
for (i=0; i<n; i++) {
Srcs[i] = i;
}
#ifdef _OPENMP
#pragma omp for
#endif
for (i=0; i<n; i++) {
j = n * sprng(stream);
if (i != j) {
#ifdef _OPENMP
int l1 = omp_test_lock(&vLock[i]);
if (l1) {
int l2 = omp_test_lock(&vLock[j]);
if (l2) {
#endif
k = Srcs[i];
Srcs[i] = Srcs[j];
Srcs[j] = k;
#ifdef _OPENMP
omp_unset_lock(&vLock[j]);
}
omp_unset_lock(&vLock[i]);
}
#endif
}
}
#endif
#ifdef _OPENMP
#pragma omp barrier
#endif
MAX_NUM_PHASES = 50;
/* Initialize predecessor lists */
/* The size of the predecessor list of each vertex is bounded by
its in-degree. So we first compute the in-degree of every
vertex */
if (tid == 0) {
in_degree = (attr_id_t *) calloc(n+1, sizeof(attr_id_t));
numEdges = (attr_id_t *) malloc((n+1)*sizeof(attr_id_t));
pSums = (attr_id_t *) malloc(nthreads*sizeof(attr_id_t));
}
#ifdef _OPENMP
#pragma omp barrier
#pragma omp for
#endif
for (i=0; i<m; i++) {
v = G->endV[i];
#ifdef _OPENMP
omp_set_lock(&vLock[v]);
#endif
in_degree[v]++;
#ifdef _OPENMP
omp_unset_lock(&vLock[v]);
#endif
}
prefix_sums(in_degree, numEdges, pSums, n);
P = (plist_t *) calloc(n, sizeof(plist_t));
pListMem = (attr_id_t *) malloc(m*sizeof(attr_id_t));
for (i=0; i<n; i++) {
P[i].list = pListMem + numEdges[i];
P[i].degree = in_degree[i];
P[i].count = 0;
}
#ifdef DIAGNOSTIC
if (tid == 0) {
elapsed_time_part = get_seconds() -elapsed_time_part;
fprintf(stderr, "In-degree computation time: %lf seconds\n",
elapsed_time_part);
elapsed_time_part = get_seconds();
}
#endif
#ifdef _OPENMP
#pragma omp barrier
#endif
/* Allocate shared memory */
if (tid == 0) {
free(in_degree);
free(numEdges);
free(pSums);
}
S = (attr_id_t *) malloc(n*sizeof(attr_id_t));
sig = (double *) malloc(n*sizeof(double));
d = (attr_id_t *) malloc(n*sizeof(attr_id_t));
del = (double *) calloc(n, sizeof(double));
start = (attr_id_t *) malloc(MAX_NUM_PHASES*sizeof(attr_id_t));
end = (attr_id_t *) malloc(MAX_NUM_PHASES*sizeof(attr_id_t));
#ifdef _OPENMP
#pragma omp barrier
#endif
for (i=0; i<n; i++) {
d[i] = -1;
}
#ifdef DIAGNOSTIC
if (tid == 0) {
elapsed_time_part = get_seconds() - elapsed_time_part;
fprintf(stderr, "BC initialization time: %lf seconds\n",
elapsed_time_part);
elapsed_time_part = get_seconds();
}
#endif
#ifdef _OPENMP
#pragma omp for reduction(+:num_traversals)
#endif
for (p=0; p<numV; p++) {
#if RANDSRCS
i = Srcs[p];
#else
i = p;
#endif
if (G->numEdges[i+1] - G->numEdges[i] == 0) {
continue;
} else {
num_traversals++;
}
sig[i] = 1;
d[i] = 0;
S[0] = i;
start[0] = 0;
end[0] = 1;
count = 1;
phase_num = 0;
while (end[phase_num] - start[phase_num] > 0) {
for (vert = start[phase_num]; vert < end[phase_num]; vert++) {
v = S[vert];
for (j=G->numEdges[v]; j<G->numEdges[v+1]; j++) {
w = G->endV[j];
if (v != w) {
/* w found for the first time? */
if (d[w] == -1) {
S[count++] = w;
d[w] = d[v] + 1;
sig[w] = sig[v];
P[w].list[P[w].count++] = v;
} else if (d[w] == d[v] + 1) {
sig[w] += sig[v];
P[w].list[P[w].count++] = v;
}
}
}
}
phase_num++;
start[phase_num] = end[phase_num-1];
end[phase_num] = count;
}
phase_num--;
while (phase_num > 0) {
for (j=start[phase_num]; j<end[phase_num]; j++) {
w = S[j];
for (k = 0; k<P[w].count; k++) {
v = P[w].list[k];
del[v] = del[v] + sig[v]*(1+del[w])/sig[w];
}
#ifdef _OPENMP
omp_set_lock(&vLock[w]);
BC[w] += del[w];
omp_unset_lock(&vLock[w]);
#else
BC[w] += del[w];
#endif
}
phase_num--;
}
for (j=0; j<count; j++) {
w = S[j];
d[w] = -1;
del[w] = 0;
P[w].count = 0;
}
}
#ifdef DIAGNOSTIC
if (tid == 0) {
elapsed_time_part = get_seconds() - elapsed_time_part;
fprintf(stderr, "BC computation time: %lf seconds\n",
elapsed_time_part);
}
#endif
#ifdef _OPENMP
#pragma omp barrier
#endif
#ifdef _OPENMP
#pragma omp for
for (i=0; i<n; i++) {
omp_destroy_lock(&vLock[i]);
}
#endif
free(S);
free(pListMem);
free(P);
free(sig);
free(d);
free(del);
free(start);
free(end);
if (tid == 0) {
#ifdef _OPENMP
free(vLock);
#endif
#if RANDSRCS
free(Srcs);
#endif
#ifdef DIAGNOSTIC
elapsed_time = get_seconds() - elapsed_time;
fprintf(stderr, "Total time taken: %lf seconds\n", elapsed_time);
#endif
}
free_sprng(stream);
#ifdef _OPENMP
#pragma omp barrier
}
#endif
}
double betweennessCentrality(graph* G, DOUBLE_T* BC, int filter) {
VERT_T *S; /* stack of vertices in the order of non-decreasing
distance from s. Also used to implicitly
represent the BFS queue */
plist* P; /* predecessors of a vertex v on shortest paths from s */
DOUBLE_T* sig; /* No. of shortest paths */
LONG_T* d; /* Length of the shortest path between every pair */
DOUBLE_T* del; /* dependency of vertices */
LONG_T *in_degree, *numEdges, *pSums;
LONG_T *pListMem;
LONG_T* Srcs;
LONG_T *start, *end;
LONG_T MAX_NUM_PHASES;
LONG_T *psCount;
#ifdef _OPENMP
omp_lock_t* vLock;
LONG_T chunkSize;
#endif
int seed = 2387;
double elapsed_time;
#ifdef _OPENMP
#pragma omp parallel
{
#endif
VERT_T *myS, *myS_t;
LONG_T myS_size;
LONG_T i, j, k, p, count, myCount;
LONG_T v, w, vert;
LONG_T numV, num_traversals, n, m, phase_num;
LONG_T tid, nthreads;
int* stream;
#ifdef DIAGNOSTIC
double elapsed_time_part;
#endif
#ifdef _OPENMP
int myLock;
tid = omp_get_thread_num();
nthreads = omp_get_num_threads();
#else
tid = 0;
nthreads = 1;
#endif
#ifdef DIAGNOSTIC
if (tid == 0) {
elapsed_time_part = get_seconds();
}
#endif
/* numV: no. of vertices to run BFS from = 2^K4approx */
numV = 1<<K4approx;
n = G->n;
m = G->m;
/* Permute vertices */
if (tid == 0) {
Srcs = (LONG_T *) malloc(n*sizeof(LONG_T));
#ifdef _OPENMP
vLock = (omp_lock_t *) malloc(n*sizeof(omp_lock_t));
#endif
}
#ifdef _OPENMP
#pragma omp barrier
#pragma omp for
for (i=0; i<n; i++) {
omp_init_lock(&vLock[i]);
}
#endif
/* Initialize RNG stream */
stream = init_sprng(0, tid, nthreads, seed, SPRNG_DEFAULT);
#ifdef _OPENMP
#pragma omp for
#endif
for (i=0; i<n; i++) {
Srcs[i] = i;
}
#ifdef _OPENMP
#pragma omp for
#endif
for (i=0; i<n; i++) {
j = n*sprng(stream);
if (i != j) {
#ifdef _OPENMP
int l1 = omp_test_lock(&vLock[i]);
if (l1) {
int l2 = omp_test_lock(&vLock[j]);
if (l2) {
#endif
k = Srcs[i];
Srcs[i] = Srcs[j];
Srcs[j] = k;
#ifdef _OPENMP
omp_unset_lock(&vLock[j]);
}
omp_unset_lock(&vLock[i]);
}
#endif
}
}
#ifdef _OPENMP
#pragma omp barrier
#endif
#ifdef DIAGNOSTIC
if (tid == 0) {
elapsed_time_part = get_seconds() -elapsed_time_part;
fprintf(stderr, "Vertex ID permutation time: %lf seconds\n", elapsed_time_part);
elapsed_time_part = get_seconds();
}
#endif
/* Start timing code from here */
if (tid == 0) {
elapsed_time = get_seconds();
#ifdef VERIFYK4
MAX_NUM_PHASES = 2*sqrt(n);
#else
MAX_NUM_PHASES = 50;
#endif
}
#ifdef _OPENMP
#pragma omp barrier
#endif
/* Initialize predecessor lists */
/* The size of the predecessor list of each vertex is bounded by
its in-degree. So we first compute the in-degree of every
vertex */
if (tid == 0) {
P = (plist *) calloc(n, sizeof(plist));
in_degree = (LONG_T *) calloc(n+1, sizeof(LONG_T));
numEdges = (LONG_T *) malloc((n+1)*sizeof(LONG_T));
pSums = (LONG_T *) malloc(nthreads*sizeof(LONG_T));
}
#ifdef _OPENMP
#pragma omp barrier
#pragma omp for
#endif
for (i=0; i<m; i++) {
v = G->endV[i];
#ifdef _OPENMP
omp_set_lock(&vLock[v]);
#endif
in_degree[v]++;
#ifdef _OPENMP
omp_unset_lock(&vLock[v]);
#endif
}
prefix_sums(in_degree, numEdges, pSums, n);
if (tid == 0) {
pListMem = (LONG_T *) malloc(m*sizeof(LONG_T));
}
#ifdef _OPENMP
#pragma omp barrier
#pragma omp for
#endif
for (i=0; i<n; i++) {
P[i].list = pListMem + numEdges[i];
P[i].degree = in_degree[i];
P[i].count = 0;
}
#ifdef DIAGNOSTIC
if (tid == 0) {
elapsed_time_part = get_seconds() - elapsed_time_part;
fprintf(stderr, "In-degree computation time: %lf seconds\n", elapsed_time_part);
elapsed_time_part = get_seconds();
}
#endif
/* Allocate shared memory */
if (tid == 0) {
free(in_degree);
free(numEdges);
free(pSums);
S = (VERT_T *) malloc(n*sizeof(VERT_T));
sig = (DOUBLE_T *) malloc(n*sizeof(DOUBLE_T));
d = (LONG_T *) malloc(n*sizeof(LONG_T));
del = (DOUBLE_T *) calloc(n, sizeof(DOUBLE_T));
start = (LONG_T *) malloc(MAX_NUM_PHASES*sizeof(LONG_T));
end = (LONG_T *) malloc(MAX_NUM_PHASES*sizeof(LONG_T));
psCount = (LONG_T *) malloc((nthreads+1)*sizeof(LONG_T));
}
/* local memory for each thread */
myS_size = (2*n)/nthreads;
myS = (LONG_T *) malloc(myS_size*sizeof(LONG_T));
num_traversals = 0;
myCount = 0;
#ifdef _OPENMP
#pragma omp barrier
#endif
#ifdef _OPENMP
#pragma omp for
#endif
for (i=0; i<n; i++) {
d[i] = -1;
}
#ifdef DIAGNOSTIC
if (tid == 0) {
elapsed_time_part = get_seconds() -elapsed_time_part;
fprintf(stderr, "BC initialization time: %lf seconds\n", elapsed_time_part);
elapsed_time_part = get_seconds();
}
#endif
for (p=0; p<n; p++) {
i = Srcs[p];
//printf ("%d \n", i);
// i = p;
if (G->numEdges[i+1] - G->numEdges[i] == 0) {
continue;
} else {
num_traversals++;
}
if (num_traversals == numV + 1) {
break;
}
if (tid == 0) {
sig[i] = 1;
d[i] = 0;
S[0] = i;
start[0] = 0;
end[0] = 1;
}
count = 1;
phase_num = 0;
#ifdef _OPENMP
#pragma omp barrier
#endif
while (end[phase_num] - start[phase_num] > 0) {
myCount = 0;
#ifdef _OPENMP
#pragma omp barrier
#pragma omp for schedule(dynamic)
#endif
for (vert = start[phase_num]; vert < end[phase_num]; vert++) {
v = S[vert];
for (j=G->numEdges[v]; j<G->numEdges[v+1]; j++) {
if ((G->weight[j] & 7) == 0 && filter==1) continue;
w = G->endV[j];
if (v != w) {
#ifdef _OPENMP
myLock = omp_test_lock(&vLock[w]);
if (myLock) {
#endif
/* w found for the first time? */
if (d[w] == -1) {
if (myS_size == myCount) {
/* Resize myS */
myS_t = (LONG_T *)
malloc(2*myS_size*sizeof(VERT_T));
memcpy(myS_t, myS, myS_size*sizeof(VERT_T));
free(myS);
myS = myS_t;
myS_size = 2*myS_size;
}
myS[myCount++] = w;
d[w] = d[v] + 1;
sig[w] = sig[v];
P[w].list[P[w].count++] = v;
} else if (d[w] == d[v] + 1) {
sig[w] += sig[v];
P[w].list[P[w].count++] = v;
}
#ifdef _OPENMP
omp_unset_lock(&vLock[w]);
} else {
if ((d[w] == -1) || (d[w] == d[v]+ 1)) {
omp_set_lock(&vLock[w]);
sig[w] += sig[v];
P[w].list[P[w].count++] = v;
omp_unset_lock(&vLock[w]);
}
}
#endif
}
}
}
/* Merge all local stacks for next iteration */
phase_num++;
psCount[tid+1] = myCount;
#ifdef _OPENMP
#pragma omp barrier
#endif
if (tid == 0) {
start[phase_num] = end[phase_num-1];
psCount[0] = start[phase_num];
for(k=1; k<=nthreads; k++) {
psCount[k] = psCount[k-1] + psCount[k];
}
end[phase_num] = psCount[nthreads];
}
#ifdef _OPENMP
#pragma omp barrier
#endif
for (k = psCount[tid]; k < psCount[tid+1]; k++) {
S[k] = myS[k-psCount[tid]];
}
#ifdef _OPENMP
#pragma omp barrier
#endif
count = end[phase_num];
}
phase_num--;
#ifdef _OPENMP
#pragma omp barrier
#endif
//printf ("%d\n", phase_num);
while (phase_num > 0) {
#ifdef _OPENMP
#pragma omp for
#endif
for (j=start[phase_num]; j<end[phase_num]; j++) {
w = S[j];
for (k = 0; k<P[w].count; k++) {
v = P[w].list[k];
#ifdef _OPENMP
omp_set_lock(&vLock[v]);
#endif
del[v] = del[v] + sig[v]*(1+del[w])/sig[w];
#ifdef _OPENMP
omp_unset_lock(&vLock[v]);
#endif
}
BC[w] += del[w];
}
phase_num--;
#ifdef _OPENMP
#pragma omp barrier
#endif
}
#ifdef _OPENMP
chunkSize = n/nthreads;
#pragma omp for schedule(static, chunkSize)
#endif
for (j=0; j<count; j++) {
w = S[j];
//fprintf (stderr, "w: %d\n", w);
d[w] = -1;
del[w] = 0;
P[w].count = 0;
}
#ifdef _OPENMP
#pragma omp barrier
#endif
}
#ifdef DIAGNOSTIC
if (tid == 0) {
elapsed_time_part = get_seconds() -elapsed_time_part;
fprintf(stderr, "BC computation time: %lf seconds\n", elapsed_time_part);
}
#endif
#ifdef _OPENMP
#pragma omp for
for (i=0; i<n; i++) {
omp_destroy_lock(&vLock[i]);
}
#endif
free(myS);
if (tid == 0) {
free(S);
free(pListMem);
free(P);
free(sig);
free(d);
free(del);
#ifdef _OPENMP
free(vLock);
#endif
free(start);
free(end);
free(psCount);
elapsed_time = get_seconds() - elapsed_time;
free(Srcs);
}
free_sprng(stream);
#ifdef _OPENMP
}
#endif
/* Verification */
#ifdef VERIFYK4
double BCval;
if (SCALE % 2 == 0) {
BCval = 0.5*pow(2, 3*SCALE/2)-pow(2, SCALE)+1.0;
} else {
BCval = 0.75*pow(2, (3*SCALE-1)/2)-pow(2, SCALE)+1.0;
}
int failed = 0;
for (int i=0; i<G->n; i++) {
if (round(BC[i] - BCval) != 0) {
failed = 1;
break;
}
}
if (failed) {
fprintf(stderr, "Kernel 4 failed validation!\n");
} else {
fprintf(stderr, "Kernel 4 validation successful!\n");
}
#endif
for (int i = 0; i < G->n; i++) printf ("BC: %d %f\n",i, BC[i]);
return elapsed_time;
}
double genScalData(graphSDG* SDGdata) {
VERT_T *src, *dest;
WEIGHT_T *wt;
LONG_T n, m;
VERT_T *permV;
#ifdef _OPENMP
omp_lock_t* vLock;
#endif
double elapsed_time;
int seed;
n = N;
m = M;
/* allocate memory for edge tuples */
src = (VERT_T *) malloc(M*sizeof(VERT_T));
dest = (VERT_T *) malloc(M*sizeof(VERT_T));
assert(src != NULL);
assert(dest != NULL);
/* sprng seed */
seed = 2387;
elapsed_time = get_seconds();
#ifdef _OPENMP
#if PARALLEL_SDG
omp_set_num_threads(omp_get_max_threads());
// omp_set_num_threads(16);
#else
omp_set_num_threads(1);
#endif
#endif
#ifdef _OPENMP
#pragma omp parallel
{
#endif
int tid, nthreads;
#ifdef DIAGNOSTIC
double elapsed_time_part;
#endif
int *stream;
LONG_T i, j, u, v, step;
DOUBLE_T av, bv, cv, dv, p, S, var;
LONG_T tmpVal;
#ifdef _OPENMP
nthreads = omp_get_num_threads();
tid = omp_get_thread_num();
#else
nthreads = 1;
tid = 0;
#endif
/* Initialize RNG stream */
stream = init_sprng(0, tid, nthreads, seed, SPRNG_DEFAULT);
#ifdef DIAGNOSTIC
if (tid == 0)
elapsed_time_part = get_seconds();
#endif
/* Start adding edges */
#ifdef _OPENMP
#pragma omp for
#endif
for (i=0; i<m; i++) {
u = 1;
v = 1;
step = n/2;
av = A;
bv = B;
cv = C;
dv = D;
p = sprng(stream);
if (p < av) {
/* Do nothing */
} else if ((p >= av) && (p < av+bv)) {
v += step;
} else if ((p >= av+bv) && (p < av+bv+cv)) {
u += step;
} else {
u += step;
v += step;
}
for (j=1; j<SCALE; j++) {
step = step/2;
/* Vary a,b,c,d by up to 10% */
var = 0.1;
av *= 0.95 + var * sprng(stream);
bv *= 0.95 + var * sprng(stream);
cv *= 0.95 + var * sprng(stream);
dv *= 0.95 + var * sprng(stream);
S = av + bv + cv + dv;
av = av/S;
bv = bv/S;
cv = cv/S;
dv = dv/S;
/* Choose partition */
p = sprng(stream);
if (p < av) {
/* Do nothing */
} else if ((p >= av) && (p < av+bv)) {
v += step;
} else if ((p >= av+bv) && (p < av+bv+cv)) {
u += step;
} else {
u += step;
v += step;
}
}
src[i] = u-1;
dest[i] = v-1;
}
#ifdef DIAGNOSTIC
if (tid == 0) {
elapsed_time_part = get_seconds() -elapsed_time_part;
fprintf(stderr, "Tuple generation time: %lf seconds\n", elapsed_time_part);
elapsed_time_part = get_seconds();
}
#endif
/* Generate vertex ID permutations */
if (tid == 0) {
permV = (VERT_T *) malloc(N*sizeof(VERT_T));
assert(permV != NULL);
}
#ifdef _OPENMP
#pragma omp barrier
#pragma omp for
#endif
for (i=0; i<n; i++) {
permV[i] = i;
}
#ifdef _OPENMP
if (tid == 0) {
vLock = (omp_lock_t *) malloc(n*sizeof(omp_lock_t));
assert(vLock != NULL);
}
#pragma omp barrier
#pragma omp for
for (i=0; i<n; i++) {
omp_init_lock(&vLock[i]);
}
#endif
#ifdef _OPENMP
#pragma omp for
#endif
for (i=0; i<n; i++) {
j = n*sprng(stream);
if (i != j) {
#ifdef _OPENMP
int l1 = omp_test_lock(&vLock[i]);
if (l1) {
int l2 = omp_test_lock(&vLock[j]);
if (l2) {
#endif
tmpVal = permV[i];
permV[i] = permV[j];
permV[j] = tmpVal;
#ifdef _OPENMP
omp_unset_lock(&vLock[j]);
}
omp_unset_lock(&vLock[i]);
}
#endif
}
}
#ifdef _OPENMP
#pragma omp for
for (i=0; i<n; i++) {
omp_destroy_lock(&vLock[i]);
}
#pragma omp barrier
if (tid == 0) {
free(vLock);
}
#endif
#ifdef _OPENMP
#pragma omp for
#endif
for (i=0; i<m; i++) {
src[i] = permV[src[i]];
dest[i] = permV[dest[i]];
}
#ifdef DIAGNOSTIC
if (tid == 0) {
elapsed_time_part = get_seconds() - elapsed_time_part;
fprintf(stderr, "Permuting vertex IDs: %lf seconds\n", elapsed_time_part);
elapsed_time_part = get_seconds();
}
#endif
if (tid == 0) {
free(permV);
}
/* Generate edge weights */
if (tid == 0) {
wt = (WEIGHT_T *) malloc(M*sizeof(WEIGHT_T));
assert(wt != NULL);
}
#ifdef _OPENMP
#pragma omp barrier
#pragma omp for
#endif
for (i=0; i<m; i++) {
wt[i] = 1 + MaxIntWeight * sprng(stream);
}
#ifdef DIAGNOSTIC
if (tid == 0) {
elapsed_time_part = get_seconds() - elapsed_time_part;
fprintf(stderr, "Generating edge weights: %lf seconds\n", elapsed_time_part);
elapsed_time_part = get_seconds();
}
#endif
SDGdata->n = n;
SDGdata->m = m;
SDGdata->startVertex = src;
SDGdata->endVertex = dest;
SDGdata->weight = wt;
free_sprng(stream);
#ifdef _OPENMP
}
#endif
elapsed_time = get_seconds() - elapsed_time;
return elapsed_time;
}
main(int argc, char *argv[])
{
double rn;
int i, myid, len, nprocs;
MPI_Status status;
char *packed;
int gtype; /*--- */
/************************** MPI calls ************************************/
MPI_Init(&argc, &argv); /* Initialize MPI */
MPI_Comm_rank(MPI_COMM_WORLD, &myid); /* find process id */
MPI_Comm_size(MPI_COMM_WORLD, &nprocs); /* find number of processes */
if(nprocs < 2)
{
fprintf(stderr,"ERROR: At least 2 processes required\n");
MPI_Finalize();
exit(1);
}
/*--- node 0 is reading in a generator type */
if(myid == 0)
{
#include "gen_types_menu.h"
printf("Type in a generator type (integers: 0,1,2,3,4,5): ");
scanf("%d", >ype);
}
MPI_Bcast(>ype,1,MPI_INT,0,MPI_COMM_WORLD ); /*--- broadcast gen type */
if (myid==0) /*********** process 0 sends stream to process 1 ***********/
{
init_sprng(gtype,SEED,SPRNG_DEFAULT); /*initialize stream */
printf("\n\nProcess %d: Print information about stream:\n",myid);
print_sprng();
printf("Process %d: Print 2 random numbers in [0,1):\n", myid);
for (i=0;i<2;i++)
{
rn = sprng(); /* generate double precision random number */
printf("Process %d: %f\n", myid, rn);
}
len = pack_sprng(&packed); /* pack stream into an array */
/* inform process 1 how many bytes process 0 will send. */
MPI_Send(&len, 1, MPI_INT, 1, 0, MPI_COMM_WORLD);
MPI_Send(packed, len, MPI_BYTE, 1, 0, MPI_COMM_WORLD); /* send stream */
free(packed); /* free storage for array */
printf(" Process 0 sends stream to process 1\n");
}
else if(myid == 1) /****** process 1 receives stream from process 0 *****/
{
init_sprng(gtype,SEED,SPRNG_DEFAULT); /*initialize stream */
MPI_Recv(&len, 1, MPI_INT, 0, MPI_ANY_TAG,
MPI_COMM_WORLD, &status); /* receive buffer size required */
if ((packed = (char *) malloc(len)) == NULL) /* allocate array */
{
fprintf(stderr,"ERROR: process %d: Cannot allocate memory\n", myid);
MPI_Finalize();
exit(1);
}
MPI_Recv(packed, len, MPI_BYTE, 0, MPI_ANY_TAG,
MPI_COMM_WORLD, &status); /* receive packed stream */
unpack_sprng(packed); /* unpack stream */
printf(" Process 1 has received the packed stream\n");
printf("Process %d: Print information about stream:\n",myid);
print_sprng();
free(packed); /* free array of packed stream */
printf(" Process 1 prints 2 numbers from received stream:\n");
for (i=0;i<2;i++)
{
rn = sprng(); /* generate double precision random number */
printf("Process %d: %f\n", myid, rn);
}
}
MPI_Finalize(); /* terminate MPI */
}
/*
* Get the oscillator function
*/
short int OscilGen::get(float *smps, float freqHz, int resonance)
{
if(needPrepare())
prepare();
fft_t *input = freqHz > 0.0f ? oscilFFTfreqs : pendingfreqs;
int outpos =
(int)((RND * 2.0f
- 1.0f) * synth.oscilsize_f * (Prand - 64.0f) / 64.0f);
outpos = (outpos + 2 * synth.oscilsize) % synth.oscilsize;
clearAll(outoscilFFTfreqs, synth.oscilsize);
int nyquist = (int)(0.5f * synth.samplerate_f / fabs(freqHz)) + 2;
if(ADvsPAD)
nyquist = (int)(synth.oscilsize / 2);
if(nyquist > synth.oscilsize / 2)
nyquist = synth.oscilsize / 2;
//Process harmonics
{
int realnyquist = nyquist;
if(Padaptiveharmonics != 0)
nyquist = synth.oscilsize / 2;
for(int i = 1; i < nyquist - 1; ++i)
outoscilFFTfreqs[i] = input[i];
adaptiveharmonic(outoscilFFTfreqs, freqHz);
adaptiveharmonicpostprocess(&outoscilFFTfreqs[1],
synth.oscilsize / 2 - 1);
nyquist = realnyquist;
}
if(Padaptiveharmonics) //do the antialiasing in the case of adaptive harmonics
for(int i = nyquist; i < synth.oscilsize / 2; ++i)
outoscilFFTfreqs[i] = fft_t(0.0f, 0.0f);
// Randomness (each harmonic), the block type is computed
// in ADnote by setting start position according to this setting
if((Prand > 64) && (freqHz >= 0.0f) && (!ADvsPAD)) {
const float rnd = PI * powf((Prand - 64.0f) / 64.0f, 2.0f);
for(int i = 1; i < nyquist - 1; ++i) //to Nyquist only for AntiAliasing
outoscilFFTfreqs[i] *=
FFTpolar<fftw_real>(1.0f, (float)(rnd * i * RND));
}
//Harmonic Amplitude Randomness
if((freqHz > 0.1f) && (!ADvsPAD)) {
unsigned int realrnd = prng();
sprng(randseed);
float power = Pamprandpower / 127.0f;
float normalize = 1.0f / (1.2f - power);
switch(Pamprandtype) {
case 1:
power = power * 2.0f - 0.5f;
power = powf(15.0f, power);
for(int i = 1; i < nyquist - 1; ++i)
outoscilFFTfreqs[i] *= powf(RND, power) * normalize;
break;
case 2:
power = power * 2.0f - 0.5f;
power = powf(15.0f, power) * 2.0f;
float rndfreq = 2 * PI * RND;
for(int i = 1; i < nyquist - 1; ++i)
outoscilFFTfreqs[i] *= powf(fabs(sinf(i * rndfreq)), power)
* normalize;
break;
}
sprng(realrnd + 1);
}
if((freqHz > 0.1f) && (resonance != 0))
res->applyres(nyquist - 1, outoscilFFTfreqs, freqHz);
rmsNormalize(outoscilFFTfreqs, synth.oscilsize);
if((ADvsPAD) && (freqHz > 0.1f)) //in this case the smps will contain the freqs
for(int i = 1; i < synth.oscilsize / 2; ++i)
smps[i - 1] = abs(outoscilFFTfreqs, i);
else {
fft->freqs2smps(outoscilFFTfreqs, smps);
for(int i = 0; i < synth.oscilsize; ++i)
smps[i] *= 0.25f; //correct the amplitude
}
if(Prand < 64)
return outpos;
else
return 0;
}
