Multithreading using WinAPI. Calculate PI - c

Question

I need to calculate PI using multiple threads for my homework. The problem is -- when using more than one thread, most of the time the sum is calculated incorrectly (smaller than it should be). I've spent quite some time on figuring it out, so maybe I'm overlooking something obvious. Hoping for your help.
P.S. There was a question about the same task. However, my mistake is different.
Here is my code.
#include <stdio.h>
#include <Windows.h>
#include <ctime>
#define THREAD_COUNT 2
#define N 10000000
#define BLOCK_SIZE 43087
typedef struct {
unsigned startPos;
int threadInd;
double threadSum;
bool isCalculating;
} ThreadArg;
HANDLE* threads;
HANDLE* events;
DWORD WINAPI ThreadProc(LPVOID);
void calculate(double* sum, unsigned start);
int main() {
unsigned cursor = 0;
ThreadArg* params = NULL;
threads = NULL;
if (THREAD_COUNT > 1) {
params = (ThreadArg*)malloc(sizeof(ThreadArg)*(THREAD_COUNT - 1));
threads = (HANDLE*)malloc(sizeof(HANDLE)*(THREAD_COUNT - 1));
events = (HANDLE*)malloc(sizeof(HANDLE)*(THREAD_COUNT - 1));
}
for (int i = 0; i < THREAD_COUNT - 1; ++i) {
ThreadArg arg;
arg.isCalculating = true;
arg.startPos = cursor;
arg.threadInd = i;
arg.threadSum = 0;
params[i] = arg;
threads[i] = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)ThreadProc, (LPVOID)(&params[i]), CREATE_SUSPENDED, 0);
events[i] = CreateEvent(NULL, TRUE, TRUE, NULL);
cursor += BLOCK_SIZE;
}
unsigned startTime = clock();
for (int i = 0; i < THREAD_COUNT - 1; ++i) {
ResumeThread(threads[i]);
}
double mainSum = 0;
while (cursor < N) {
for (int i = 0; i < THREAD_COUNT - 1; ++i) {
if (!params[i].isCalculating) {
params[i].startPos = cursor;
SetEvent(events[i]);
cursor += BLOCK_SIZE;
}
}
calculate(&mainSum, cursor);
cursor += BLOCK_SIZE;
}
bool allFinished;
do {
allFinished = true;
for (int i = 0; i < THREAD_COUNT - 1; ++i) {
if (params[i].isCalculating) {
allFinished = false;
break;
}
}
} while(!allFinished);
for (int i = 0; i < THREAD_COUNT - 1; ++i) {
mainSum += params[i].threadSum;
CloseHandle(threads[i]);
}
printf("Time: %d\n", clock() - startTime);
printf("PI = %.7f\n", mainSum/N);
free(threads);
free(params);
system("pause");
}
DWORD WINAPI ThreadProc(LPVOID lParam) {
ThreadArg* param = (ThreadArg*)lParam;
while (true) {
ResetEvent(events[param->threadInd]);
calculate(&param->threadSum, param->startPos);
InterlockedDecrement((LONG*)&param->isCalculating);
WaitForSingleObject(events[param->threadInd], INFINITE);
InterlockedIncrement((LONG*)&param->isCalculating);
}
}
void calculate(double* sum, unsigned start) {
int endLoop = start + BLOCK_SIZE;
double x;
for (unsigned i = start; i < endLoop; ++i) {
if (i < N) {
x = (i + 0.5) / N;
*sum += 4 / (1 + x*x);
} else break;
}
}

Answer 1

you not need events at all. working thread never must wait. all can be done with interlocked operations.
class CALC_TASK
{
C_ASSERT(sizeof(double)==sizeof(__int64));
union {
double _sum;
__int64 _value;
};
double _step;
LONG _startPos, _maxPos, _blockSize;
static double calculate(LONG i, LONG count, double step)
{
double x, sum = 0.0;
do
{
x = (i-- - 0.5) * step;
sum += 4.0 / (1.0 + x*x);
} while (--count);
return step * sum;
}
void add(double x)
{
union {
double sum;
__int64 value;
};
union {
double new_sum;
__int64 new_value;
};
sum = _sum;
for ( ; ; value = new_value)
{
new_sum = sum + x;
new_value = _InterlockedCompareExchange64(&_value, new_value, value);
if (new_value == value)
{
return;
}
}
}
BOOL getBlock(LONG& pos, LONG& count)
{
LONG startPos, newPos, curPos;
for (startPos = _startPos ; startPos < _maxPos; startPos = curPos)
{
if ((newPos = startPos + _blockSize) > _maxPos)
{
newPos = _maxPos;
}
curPos = _InterlockedCompareExchange(&_startPos, newPos, startPos);
if (curPos == startPos)
{
pos = newPos, count = newPos - startPos;
return TRUE;
}
}
return FALSE;
}
void calculateEx()
{
LONG i, count;
double step = _step;
while (getBlock(i, count))
{
add(calculate(i, count, step));
}
}
public:
double getsum()
{
return _sum;
}
CALC_TASK(LONG maxPos, LONG blockSize)
{
_startPos = 0, _blockSize = blockSize, _maxPos = maxPos, _sum = 0.0, _step = 1.0 / (double)maxPos;
}
static DWORD CALLBACK ThreadProc(PVOID pct)
{
reinterpret_cast<CALC_TASK*>(pct)->calculateEx();
return 0;
}
};
double test(LONG maxPos, LONG blockSize)
{
SYSTEM_INFO si;
GetNativeSystemInfo(&si);
PHANDLE phThreads = 0;
ULONG nThreads = 0;
CALC_TASK ct(maxPos, blockSize);
if (1 < si.dwNumberOfProcessors)
{
ULONG n = si.dwNumberOfProcessors - 1;
phThreads = (HANDLE*)alloca(n * sizeof(HANDLE));
do
{
if (*phThreads = CreateThread(NULL, PAGE_SIZE, CALC_TASK::ThreadProc, &ct, 0, 0))
{
nThreads++, phThreads++;
}
} while (--n);
}
CALC_TASK::ThreadProc(&ct);
if (nThreads)
{
WaitForMultipleObjects(nThreads, phThreads - nThreads, TRUE, INFINITE);
do
{
CloseHandle(*--phThreads);
} while (--nThreads);
}
return ct.getsum();
}
void testEx()
{
ULONG dwStart = GetTickCount();
double d = test(0x10000000, 0x8000);
dwStart = GetTickCount() - dwStart;
DbgPrint("pi = %.15f, %u milliseconds\n", d, dwStart);
}
in my test with 8 core/treads it take ~ 0.5 second for 0x10000000 steps. with single thread this take ~3.5 seconds.
as alternative you can use openMP
double calculateOMP(int num_steps)
{
double x, sum = 0.0, step = 1.0 / (double) num_steps;
#pragma omp parallel for reduction(+:sum) private(x)
for (int i = num_steps; i > 0; --i)
{
x = (i - 0.5) * step;
sum += 4.0 / (1.0 + x*x);
}
return step * sum;
}
for this you need use /openmp option and add vcomp.lib to linker input