alldcprogs.c

//Solving Cache Coherence with Padding
struct padded_int
{
    int val;
    char padding[60];
} private_count[MAX_THREADS];

//Peril-R
forall(index in (1..12))
exclusive {}
barrier()
__data__
localize()

//Peril-R Count 3s colution
int __count__=0, local=0;
int arr[10] = {1,2,3,3,2,1,1,2,3,1}
forall(index in (0..10))
{
    if(arr[index]==3){
        local+=1;
    }
}
exclusive {
    __count__ += local;
}
printf("Total 3's:%d", __count__);

//Generic Reduce
tally = init()
for(i=0;i<size;i++){
    tally=accum(tally, myData[i])
}
nodeval[index] = tally;
while(stride<P){
    if(index%(2*stride)==0){
        nodeval[index]=combine(nodeval[index],nodeval[index+stride]);
        stride = 2*stride;
    }
    else
    {
        break;
    }
    if(index==0){
        result = reduceGen(nodeval[0]);
    }
}

//Generic Scan
int nodeval[p];
int tally[p];
forall(index in (0..p-1)){
    int mydata[size] = localize(operandArray[])
    int ltally, righttally;
    int stride = 1;
    tally=init();
    for(i=0;i<size;i++){
        tally=accum(tally,myData[i]);
    }
    while(stride<P){
        if(index%(2*stride)==0){
            ltally[index+stride] = nodeval[index];
            nodeval[index] = combine(ltally[index+stride],nodeval[index+stride]);
            stride = 2*stride;
        }
        else {
            break;
        }
    }
    stride = P/2;
    if(index==0){
        ptally = nodeval[0];
        nodeval[0] = init();
    }
    while(stride>1){
        ptally = node[index];
        nodeval[index] = ptally;
        nodeval[index+stride] = combine(ptally,ltally[index+stride]);
        stride = stride/2;
    }
    for(i=0;i<size;i++){
        myResult[i]= ScanGen(ptally,myData[i]);
    }
}

//Collatz Conjecture
float ef = 1;
int besta = 1;
int head = 0;
forall(index in (0..p-1)){
    int a=1;
    float myEF = 1;
    int big, atest = 1;
    while(a<runsize){
        exclusive{
            a=q[head];
            __q[head]__ = a+p;
            head=(head+1)%p;
        }
        atest=a;
        big=a;
        while(atest!=1){
            if(even(atest)){
                atest = atest/2;
            }
            else{
                atest=atest*3+1;
            }
            big = max(big,atest);
        }
    }
    myE = big/a;
    exclusive {
        if(myEF>ef){
            ef=myEF;
            besta = a;
        }
    }
}

//Thread Creation
#include <pthread.h>
#include <stdlib.h>
#include <stdio.h>

int main(){
    int err;
    pthread_t tid[max];
    for(i=0;i<t;i++){
        err = pthread_create(&tid[i],NULL,count3s_thread,i);
    }
    for(i=0;i<t;i++){
        err=pthread_join(tid[i],(void **), &status[i]);
    }
    return 0;
}

//Count 3s using openmp
#include <omp.h>
#include <stdlib.h>
#include <stdio.h>

int main(){
    int i, count_p;
    int count =0;
    #pragma omp parallel shared(array, count,lengths) private(count_p)
    {
        count_p=0;
        #pragma omp parallel for private(i)
        for(i=0;i<length;i++){
            if(array[i]==3){
                count_p++;
            }
        }
        #pragma omp critical
        {
            count+=count_p;
        }
    }
    printf("Count:%d",count);
    return 0;
}

//Count3s in MPI
#include <stdio.h>
#include <mpi.h>
#include <globals.h>

int main(){
    MPI_Status status;
    int rank,size;
    int local=0,count=0;

    MPI_Init(NULL,NULL);
    MPI_Comm_rank(MPI_COMMON_WORLD,&rank);
    MPI_Comm_size(MPI_COMMON_WORLD,&size);

    int arr[10] = {1,2,3,3,2,1,1,2,3,3};

    for(int i=rank*10/size,i<(rank+1)*10/size;i++){
        if(arr[i]==3){
            local+=1;
        }
    }
    
    MPI_Reduce(&local,&global,1,MPI_DOUBLE,MPI_SUM,0,MPI_COMMON_WORLD);
    if(rank==0){
        printf("No. of 3's:%d",count);
    }
    MPI_Finalize();
    return 0;
}

//Co Array Fortran
real dimension (n,n) [p,*] .. a,b,c
do k=1,n
    do q=1,p
        c[i, myQ, myP] = c(i,j)[myP,myQ]+a[i,k][myP,q]*b(k,j)[q,myQ]
    enddo
enddo

//UPD
upc_forall()

//Ti
foreach(ij in C.domain()){
    double [1d] arr = a.slice(1,ij[7]);
    for(k in arr){
        c[i][j] = a[k][0] + b[0][k];
    }
}