OpenMP program unexpectedly not faster with more threads - multithreading

Question

I am a newbie to OpenMP. I write a code to calculate value of Pi by calculating the area of function f(x) = 4/(1+x^2). I try to examine the efficiency with different threads. Below is my code:
int main() {
long long num_iteration = 100000000;
double pi = 0;
double x_margin = 1.0 / num_iteration;
double start_time, end_time;
int num_threads_main = 0;
int j = NUM_THREAD;
int a;
for(a = 1; a <= j; a++) {
pi = 0.0;
omp_set_num_threads(a);
start_time = omp_get_wtime();
#pragma omp parallel
{
int i;
int ID = omp_get_thread_num();
double sum = 0.0;
int num_threads_local = omp_get_num_threads();
double x_value = 0;
if(ID == 0)
num_threads_main = num_threads_local;
for (i = ID; i < num_iteration; i = i + num_threads_local) {
x_value = x_margin * ( i + 0.5 );
sum = sum + ( 4.0 / (1.0 + x_value * x_value));
}
#pragma critical
pi = pi + sum * x_margin;
}
end_time = omp_get_wtime() - start_time;
printf("pi with 1000000000 steps is %f in %f seconds with threads %d\n", pi, end_time, num_threads_main);
}
return 0;
}
However, when I got a strange result:
pi with 1000000000 steps is 3.141593 in 0.333257 seconds with threads 1
pi with 1000000000 steps is 3.141593 in 0.175574 seconds with threads 2
pi with 1000000000 steps is 3.141593 in 0.177884 seconds with threads 3
pi with 1000000000 steps is 3.141593 in 0.170591 seconds with threads 4
Why my program is not faster when there are more threads? I know there might be some overhead for OpenMP. However, I compare my code with Tim Mattson's code for OpenMP tutorial. I find quite a resemblance between the two. Below is his code:
static long num_steps = 100000000;
double step;
int main ()
{
int i,j;
double pi, full_sum = 0.0;
double start_time, run_time;
double sum[MAX_THREADS];
step = 1.0/(double) num_steps;
for(j=1;j<=MAX_THREADS ;j++){
omp_set_num_threads(j);
full_sum = 0.0;
start_time = omp_get_wtime();
#pragma omp parallel private(i)
{
int id = omp_get_thread_num();
int numthreads = omp_get_num_threads();
double x;
double partial_sum = 0;
#pragma omp single
printf(" num_threads = %d",numthreads);
for (i=id;i< num_steps; i+=numthreads){
x = (i+0.5)*step;
partial_sum += + 4.0/(1.0+x*x);
}
#pragma omp critical
full_sum += partial_sum;
}
pi = step * full_sum;
run_time = omp_get_wtime() - start_time;
printf("\n pi is %f in %f seconds %d threds \n ",pi,run_time,j);
}
}
And this is his result:
num_threads = 1
pi is 3.141593 in 0.483153 seconds 1 threds
num_threads = 2
pi is 3.141593 in 0.305407 seconds 2 threds
num_threads = 3
pi is 3.141593 in 0.246802 seconds 3 threds
num_threads = 4
pi is 3.141593 in 0.204905 seconds 4 threds
I do the experiment on my MacOS 10.15.3 with a 2.3 GHz Dual-Core Intel Core i5. Am I missing something. Thank you.