#include<iostream>
#include<omp.h>

using namespace std;

//functie pentru varianta secventiala ce determina numarul de numere prime intre 1 si N

int getNumarPrime(long long N)
{
    int contor = 0;
    for (long long i = 0; i < N; i++)
    {
        bool estePrim = true;
        for (long long j = 2; j < i / 2; j++)
        {
            if (i%j == 0)
            {
                estePrim = false;
                break;
            }
        }
        if (estePrim)
        {
            contor++;
        }
    }
    return contor;
}

int getNumarPrimeParalel(long long N)
{
    int contor = 0;
    //problema de race condition pe contor
#pragma omp parallel num_threads(4) shared(contor)
    {
        int idThread = omp_get_thread_num();
        int nrThreaduri = omp_get_num_threads();

        long long limitaSuperioara = (idThread + 1) / nrThreaduri * N;
        long long limitaInferioara = idThread / nrThreaduri * N;

        for (long long i = limitaInferioara; i < limitaSuperioara; i++)
        {
            bool estePrim = true;
            for (long long j = 2; j < i / 2; j++)
            {
                if (i%j == 0)
                {
                    estePrim = false;
                    break;
                }
            }
            if (estePrim)
            {
                contor++;
            }
        }
    }
    return contor;
}


//rezolva problema de race condition
int getNumarPrimeParalel2(long long N)
{
    int contor = 0;
    int contorLocal = 0;

#pragma omp parallel num_threads(4) shared(contor) private(contorLocal)
    {
        contorLocal = 0;

        int idThread = omp_get_thread_num();
        int nrThreaduri = omp_get_num_threads();

        long long limitaSuperioara = (idThread + 1) / nrThreaduri * N;
        long long limitaInferioara = idThread / nrThreaduri * N;

        for (long long i = limitaInferioara; i < limitaSuperioara; i++)
        {
            bool estePrim = true;
            for (long long j = 2; j < i / 2; j++)
            {
                if (i%j == 0)
                {
                    estePrim = false;
                    break;
                }
            }
            if (estePrim)
            {
                contorLocal++;
            }
        }
#pragma omp critical
        contor += contorLocal;
    }
    return contor;
}

//rezolva race condition si foloseste structura for
int getNumarPrimeParalel3(long long N)
{
    int contor = 0;
    int contorLocal = 0;

#pragma omp parallel num_threads(4) shared(contor) private(contorLocal)
    {
        contorLocal = 0;

        int idThread = omp_get_thread_num();
        int nrThreaduri = omp_get_num_threads();

#pragma omp for
        for (long long i = 0; i < N; i++)
        {
            bool estePrim = true;
            for (long long j = 2; j < i / 2; j++)
            {
                if (i%j == 0)
                {
                    estePrim = false;
                    break;
                }
            }
            if (estePrim)
            {
                contorLocal++;
            }
        }
#pragma omp critical
        contor += contorLocal;
    }
    return contor;
}

//rezolva race condition si foloseste structura for
int getNumarPrimeParalel4(long long N)
{
    int contor = 0;
/* \ poti sa pui pe mai multe randuri */
#pragma omp parallel for num_threads(4) \
reduction(+: contor)
        for (long long i = 0; i < N; i++)
        {
            bool estePrim = true;
            for (long long j = 2; j < i / 2; j++)
            {
                if (i%j == 0)
                {
                    estePrim = false;
                    break;
                }
            }
            if (estePrim)
            {
                contor++;
            }
        }


    return contor;
}

//functie ce demonstreaza sincronizare prin aplicarea unei bariere
void testBariera(){
#pragma omp parallel num_threads(4)
    {
        int idThread = omp_get_thread_num();
        _sleep(idThread * 1000);
        cout << endl << " Hello from " << idThread;

#pragma omp barrier

        cout << endl << idThread << " continua executia ";
    }

    cout << endl << " Sfarsit prelucrari";
}

static long long N = 2 * 1e5; //10^5

void main()
{
    /*
#pragma omp parallel num_threads(8)
    {
        cout << endl << "Hello world";
    }

    //Test varianta secventiala
    double tStart = omp_get_wtime();
    int nrPrime = getNumarPrime(N);
    double tFinal = omp_get_wtime();

    cout << endl << "Numere prime: " << nrPrime << " in " << tFinal - tStart << " ms";

    //Test varianta paralela #1

    tStart = omp_get_wtime();
    nrPrime = getNumarPrimeParalel(N);
    tFinal = omp_get_wtime();

    cout << endl << "Numere prime: " << nrPrime << " in " << tFinal - tStart << " ms";


    //Test varianta paralela #3

    tStart = omp_get_wtime();
    nrPrime = getNumarPrimeParalel3(N);
    tFinal = omp_get_wtime();

    cout << endl << "Numere prime: " << nrPrime << " in " << tFinal - tStart << " ms";


    //Test varianta paralela #4

    tStart = omp_get_wtime();
    nrPrime = getNumarPrimeParalel4(N);
    tFinal = omp_get_wtime();

    cout << endl << "Numere prime: " << nrPrime << " in " << tFinal - tStart << " ms";
    */
    testBariera();
}