PRIR Obliczanie PI sekwencyjnie i równolegle

// Alloner & JuanCorp PRIR 2017-10-12
#include <Windows.h>
#include <time.h>
#include <iostream>
#include <math.h>
#include <conio.h>
#include <cstdio>

using namespace std;

// Dane przekazywane do watku
struct MyData
{
    int ID; // Id wątku
    int IndexStart; // Poczatek
    int IndexStop;  // i koniec przedziału do obliczeń
};

double *SeqResults;

// Obliczanie PI/4 w 'tradycyjny' sposob (z mozliwoscia uzycia z watkami)
double LeibnizMethodSeq(int indexStart, int indexStop)
{
    double Result = 0.0; // Bufor wyniku

    // Obliczenia wedlug wzoru ... dla przedzialu
    for (int i = indexStart; i < indexStop; i++)
    {
        if (i % 2 == 0) // Parzysta potega
            Result += 1.0 / (2.0 * i + 1.0);
        else // Nieparzysta potega
            Result -= 1.0 / (2.0 * i + 1.0);
    }

    return Result; // Wynik (powinno wyjsc +- PI/4)
}

// Funkcja wykonywana przez kazdy watek
DWORD WINAPI LeibnizPart(LPVOID lpParam)
{
    // rzutowanie lpParam na nasz typ
    MyData *Data = (MyData*)lpParam;
    // Przypisanie wyniku 'standardowego' obliczania dla przedzialu danego watku
    // i przypisanie go do odpowiedniego miejsca w buforze
    SeqResults[Data->ID] = LeibnizMethodSeq(Data->IndexStart, Data->IndexStop);

    return 0;
}

// Obliczanie PI/4 w sposob wielowatkowy
void LeibnizMethodPar(int pressiton, int numberOfThreads)
{
    // Zmienne potrzebna do utworzenia watkow
    MyData *pDataArray = new MyData[numberOfThreads];
    DWORD *dwThreadIdArray = new DWORD[numberOfThreads];
    HANDLE *hThreadArray = new HANDLE[numberOfThreads];

    int perThread = pressiton / numberOfThreads;// Obliczenie przedzialow
    int indexStart = 0;// Bufor indexu poczatkowego

    for (int i = 0; i < numberOfThreads; i++)
    {
        pDataArray[i].ID = i; // Przypisanie ID watku
        pDataArray[i].IndexStart = indexStart; // Poczatek przedzialu
        pDataArray[i].IndexStop = indexStart + perThread; // Koniec przedzialu

        // Jesli ilosc 'pressiton % numberOfThreads != 0' przypisz reszte zakresu do ostatniego watku (np.: 9%4 = 1)
        if (i + 1 == numberOfThreads && pressiton% numberOfThreads != 0)
            pDataArray[i].IndexStop += (pressiton%numberOfThreads);

        // Utworzenie watku
        hThreadArray[i] = CreateThread(NULL, 0, LeibnizPart, &pDataArray[i], 0, &dwThreadIdArray[i]);

        // przesuniecie zakresu
        indexStart += perThread;
    }

    // Czekanie na skonczenie obliczen przez watki
    WaitForMultipleObjects(numberOfThreads, hThreadArray, TRUE, INFINITE);

    // Zamykanie uchwytow do watkow
    for (int i = 0; i < numberOfThreads; i++)
        CloseHandle(hThreadArray[i]);

}

int main()
{
    // Zmienna dla czasomierza
    int TimeStart, TimeStop;

    int Pressition = 1600000000; // Dokladnosc
    int Threads = 4; // Ilosc watkow
    double LeibnizResult = 0.0; // Wynik obliczen

    // Obliczenia dla metody 'klasycznej' - sekwencyjnej
    printf("Leibniz method sequential\n");
    TimeStart = clock();
    LeibnizResult = LeibnizMethodSeq(0, Pressition);
    TimeStop = clock();
    printf("Result: %.15lf \nTime: %d\n", 4 * LeibnizResult, TimeStop - TimeStart);

    printf("\n");
    LeibnizResult = 0.0;

    // Obliczenia dla metody wielowatkowej
    printf("Leibniz method parallel\n");
    TimeStart = clock();
    SeqResults = new double[Threads];
    LeibnizMethodPar(Pressition, Threads);
    TimeStop = clock();

    // Dodanie wynikow z bufora
    for (int i = 0; i < Threads; i++)
        LeibnizResult += SeqResults[i];

    printf("Result: %.15lf \nTime: %d\n", 4 * LeibnizResult, TimeStop - TimeStart);

    _getch();
    return 0;
}
// Alloner & JuanCorp PRIR 2017-10-12
// 9,5