Ttykuu

Hi :) Yesterday I saw a CodeTrain video in where Daniel Shiffman tried to approximate Pi using the Leibniz series. It was interesting so I decided to try it too.

I wrote this console application with a simple goal: Approximate as fast as possible as many digits of Pi the program can until it reaches the maximum number the cicle counter can achieve(without starting to commit calculation errors with the series formula) OR the program is stopped.

It starts by first running two background threads which execute two functions that do all the job: piLoop(), for calculating the series; and displayLoop(), for refreshing the screen and displaying the actual calculated Pi. To prevent concurrency problems, mutexes are used to prevent the threads from accessing Pi and other program shared variables at the same time. The program runs until piCicles reaches the maximum value a long long int can get OR the End key is pressed.

The final program runs, by glancing at it(that means a very unreliable measurement), at an approximated rate of 30 million cicles per second in my computer. That means it can calculate the 10th digit of PI(around 87 billion cicles) in about an hour.

I want to know if there are some optimizations that can be made so the program can run at all his power.

Here's the code:

main.cpp

#include <iostream>
#include <thread>
#include <mutex>
#include <chrono>
#include <windows.h>
#include <limits>

void piLoop();
void displayLoop();
void getShouldStop();

namespace 
 typedef std::numeric_limits<long double> ldbl;
 typedef std::numeric_limits<long long int> ullint;

 const char displayDigits = ldbl::max_digits10;
 const short int updateDelay_ms = 50; // You can modify this value to change the speed of console refreshing.
 const long long int maxCicles = ullint::max();

 bool shouldStop = false;
 long double PI = 0;
 unsigned long long int piCicles = 0;
 std::mutex piLock;


int main()

 std::thread piCalculatorThread( piLoop );
 std::thread displayUpdaterThread( displayLoop );
 piCalculatorThread.join();
 displayUpdaterThread.join();

 std::cin.get();

 return 0;


void getShouldStop() 
 shouldStop = GetAsyncKeyState( VK_END ) 

// If PI mutex is not locked, proceed to calculate the next PI, else wait
void piLoop() 
 while ( true ) 
 piLock.lock();

 if ( shouldStop ) 
 piLock.unlock();
 return;
 

 // Here the series is calculated
 PI += ((long double)((piCicles&1)>0 ? -1 : 1)) / (piCicles*2 + 1);

 if ( piCicles == maxCicles ) 
 shouldStop = true;
 piLock.unlock();
 return;
 

 piCicles++;

 piLock.unlock();
 


// Wait until PI mutex is unlocked, then refresh the screen.
void displayLoop() 
 std::cout.precision( displayDigits );
 while ( true ) 
 piLock.lock();

 system("cls");
 std::cout << "nn ----- PI Calculator ----- nn - "Seeing how PI is calculated is more enjoyable while eating some snacks."";
 std::cout << "nnn PI: " << PI * 4;
 std::cout << "n Cicles: " << piCicles << std::endl;
 if ( maxCicles == piCicles ) // Just in case someone has the time to run this program for long enough
 std::cout << "n Max precise 64-bit computable value reached!" << std::endl;

 if ( !shouldStop ) getShouldStop();

 piLock.unlock();

 if ( shouldStop ) return;

 std::this_thread::sleep_for( std::chrono::milliseconds( updateDelay_ms ) );
 

I think this code can also be run on other operating systems by removing the windows.h header and the getShouldStop() function as well, so Linux users may also give it a try :)

Here is a link to download the Windows executable if you want to test it.