parallelize prime sieve segmentation error - c

Question

I changed the first version of the Code linked here to make the loop on line 360 (in the Code I shared below) run in parallel.
For this I replaced the fields\variables where the results are saved by fields of field\variables so that every thread can save them without deleting the results of other threads.
Additionally I replaced the calculation of values used in every loop pass in a way that they aren't depending on the value they had in the last loop pass (So that I can calculate them just depending on the value of the loop variable).
I am going to post the entire Code here be course the Minimal example would just be 10 lines shorter but miss any possibility to Check if the result is wrong or not. No special compiler features are used, just -fopenmp (under g++) as argument is necessary.
//
// prime_sieve.c
//
// Copyright (C) July 2002, Tomás Oliveira e Silva
//
// e-mail: tos#ua.pt
// www: http://www.ieeta.pt/~tos
//
// Comparison of two simple (but serious) implementations of the segmented sieve of
// Eratosthenes. The second implementation can generate primes reasonably fast near
// 1e18 (using around 400Mbytes of memory).
//
// _implementation_=0 gives a classical segmented sieve
// _implementation_=1 gives a cache-friendly segmented sieve
//
// See timing results for the two implementations at the end.
//
// Main idea: use one linked list for each interval of the segmented sieve, putting in it
// the primes than have an odd multiple in that interval (but not in a previous interval);
// this allows a better utilization of the processor data caches, giving significant time
// savings (up to a factor of 6) when working near 1e18. The amount of memory used is
// approximately 8*pi(sqrt(N)), where N is the last number of the interval, and pi(x) is
// the usual prime counting function.
//
// Assumptions: pointers have 4 bytes, gcc compiler
//
//
// Released under the GNU general public license (version 2 or any later version); see the
// gpl.txt file (or the page http://www.gnu.org/licenses/gpl.html) for details.
//
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
#include <math.h>
#include <time.h>
#include <stdio.h>
#include <stdlib.h>
#include <omp.h>
//
// configuration specification
//
// default parameters optimized for integers near 1e18; see tables at the end
//
#define nthreads 2
#ifndef _sieve_bits_log2_
# define _sieve_bits_log2_ 19
#endif
#ifndef _bucket_size_log2_
# define _bucket_size_log2_ 10
#endif
#if _bucket_size_log2_ > 16
# error "_bucket_size_log2_ is too large"
#endif
//
// basic type definitions
//
typedef unsigned char u08;
typedef unsigned int u32;
typedef unsigned long long u64;
//
// memory allocation
//
static void *get_memory(u32 size)
{
size_t m;
m = (size_t)malloc(size + 255); // this assumes that sizeof(void *) = sizeof(size_t)
if((void *)m == NULL)
exit(1);
m = (m + (size_t)255) & ~(size_t)255;
return (void *)m; // pointer aligned on a 256 byte boundary
}
//
// count the number of zeros
//
static u32 count_zero_bits(u08 *addr,u32 size)
{
static u32 data[256];
u32 i,j;
if(data[1] == 0)
for(i = 0;i < 256;i++)
for(j = i ^ 255;j;j >>= 1)
if(j & 1)
data[i]++;
j = 0;
for(i = 0;i < size;i++)
j += data[(u32)addr[i] & 255];
return j;
}
//
// generation of the (small) primes used by the main sieve
//
#define number_of_small_primes 6541// number of primes below 2 ^ 19
static u32 small_primes[number_of_small_primes];
static u32 small_sieve[nthreads][1024];//65 536 bits
static u32 small_base[nthreads];
static void update_small_sieve(u32 th_id)
{
u32 i,j;
for(j = 0;j < 1024;j++)
small_sieve[th_id][j] = 0;
for(i = 0;i < number_of_small_primes;i++)
{
j = small_primes[i] * small_primes[i];
if(j >= small_base[th_id] + 65536)
break;
if(j < small_base[th_id])
{
j = small_base[th_id] / small_primes[i];
j *= small_primes[i];
if(j < small_base[th_id])
j += small_primes[i];
if((j & 1) == 0)
j += small_primes[i];
}
for(j = (j - small_base[th_id]) >> 1;j < 32768;j += small_primes[i])
small_sieve[th_id][j >> 5] |= 1 << (j & 31);
}
}
//
// main sieve
//
// the following structure is used to record the
// information required to sieve an interval
//
// the value of _bucket_size_log2_ should
// be small (and a multiple of the L1 or L2 data cache line size)
//
#define primes_per_bucket ((1 << (_bucket_size_log2_ - 3)) - 1)
typedef struct bucket
{
struct bucket *next; // pointer to next bucket
u32 count; // count of the number of primes in this bucket
struct
{
u32 p; // prime
u32 o; // the bit number of the first odd multiple (>= main_base) of the prime
}
data[primes_per_bucket];
}
bucket;
static u32 main_sieve[nthreads][1 << (_sieve_bits_log2_ - 5)];
static u64 main_limit; // wird nicht parallel geaendert
static bucket **main_lists[nthreads],*available_buckets[nthreads];
static u32 list_size_log2;
void more_buckets(int th_id) { u32 i,j; i = 1 << (20 - _bucket_size_log2_);
available_buckets[th_id] = (bucket *)get_memory(i * sizeof(bucket)); for(j = 0;j < i;j++)
available_buckets[th_id][j].next = (j < i - 1) ? &available_buckets[th_id][j + 1] : NULL; }
void new_bucket(u64 k,int th_id) { bucket *b; if(available_buckets[th_id] == NULL) more_buckets(th_id);
b = available_buckets[th_id]; available_buckets[th_id] = available_buckets[th_id]->next;
b->next = main_lists[th_id][k]; main_lists[th_id][k] = b; b->count = 0; }
static void init_main_sieve(const u64 main_base, const u32 th_id, u32 next_prime, const u32 current_list)
{
u64 t,end;
u32 i,j;
u32 k;
end = main_base + (u64)(2 << _sieve_bits_log2_);
if ( small_base[th_id] != (next_prime/65536) * 65536) {
small_base[th_id] = (next_prime/65536) * 65536;
update_small_sieve(th_id);
}
while((t = (u64)next_prime * (u64)next_prime) < end)
{
if(next_prime >= small_base[th_id] + 65536)
{
small_base[th_id] += 65536;
update_small_sieve(th_id);
}
// primes are (beside two) always odd so they have at least a distance of 2.
// you dont have to save information about even numbers, so divide distance by two.
i = (next_prime - small_base[th_id]) >> 1;
if((small_sieve[th_id][i >> 5] & (1 << (i & 31))) == 0)// is nextprime a prime?
{
if(t < main_base) // setze t auf das erste vielfache der Primzahl > main_base
{
t = main_base / (u64)next_prime;
t *= (u64)next_prime;
if(t < main_base)
t += (u64)next_prime;
if(((u32)t & 1) == 0)
t += (u64)next_prime;
}
i = (u32)((t - main_base) >> 1); // bit number
k = (current_list + (i >> _sieve_bits_log2_)) & ((1 << list_size_log2) - 1);
if(main_lists[th_id][k]->count == primes_per_bucket){
//#pragma omp critical
new_bucket(k, th_id);
}
j = main_lists[th_id][k]->count++;
main_lists[th_id][k]->data[j].p = next_prime;
main_lists[th_id][k]->data[j].o = i & ((1 << _sieve_bits_log2_) - 1);
}
// atomic add
next_prime += 2;
}
}
static void do_main_sieve(const u64 main_base, const u32 th_id, u32 next_prime, const u32 current_list)
{
bucket *b;
bucket *c;
u32 j,k;
u32 i,p,o;
init_main_sieve(main_base, th_id, next_prime, current_list);
for(i = 0;i < (1 << (_sieve_bits_log2_ - 5));i++)
main_sieve[th_id][i] = 0;
b = main_lists[th_id][current_list];
while(b != NULL)
{
for(i = 0;i < b->count;i++)
{
p = b->data[i].p;
for(o = b->data[i].o;o < (1 << _sieve_bits_log2_);o += p)
//finde das entsprechende u32 feld mit allen bits von o auser den 5 letzten
// und finde mit den letzten 5 bits von 0 die Stelle in dem u32 wert die du auf 1
// dh. vielfaches einer Zahl, setzt
main_sieve[th_id][o >> 5] |= 1 << (o & 31);
k = (current_list + (o >> _sieve_bits_log2_)) & ((1 << list_size_log2) - 1);
if(main_lists[th_id][k]->count == primes_per_bucket) {
//#pragma omp critical
new_bucket(k, th_id);
}
j = main_lists[th_id][k]->count++;
main_lists[th_id][k]->data[j].p = p;
main_lists[th_id][k]->data[j].o = o & ((1 << _sieve_bits_log2_) - 1);
}
c = b;
b = b->next;
c->next = available_buckets[th_id];
available_buckets[th_id] = c;
}
main_lists[th_id][current_list] = NULL;
#pragma omp critical
new_bucket(current_list, th_id);
//current_list = (current_list + 1) & ((1 << list_size_log2) - 1);
}
void set_small_primes(void)
{
u32 i,j;
if(small_primes[0] == 0)
{ // initialize the small_primes array
for(j = 0;j < 1024;j++)
small_sieve[0][j] = 0;
for(i = 3;i < 256;i += 2)// 256 ^2 = 65 536
if((small_sieve[0][i >> 6] & (1 << ((i >> 1) & 31))) == 0)
for(j = (i * i) >> 1;j < 32768;j += i)
small_sieve[0][j >> 5] |= 1 << (j & 31);
j = 0;
for(i = 3;i < 65536;i += 2)
if((small_sieve[0][i >> 6] & (1 << ((i >> 1) & 31))) == 0)
small_primes[j++] = i;
if(j != number_of_small_primes)
exit(2); // this should never happen
}
}
//
// main program
//
int main(int argc,char **argv)
{
double t;
u32 i,j;
u64 pi, counter=0;
u64 main_base;
int ntasks = 1;
u32 next_prime = 3;
u32 current_list = 0;
omp_set_num_threads(nthreads);
if(argc == 1)
i = 15;
else
i = atoi(argv[1]);
if(i < 6)
i = 6;
if(i > 18)
i = 18;
printf("%2u %2u",_sieve_bits_log2_,_bucket_size_log2_);
main_base = 1ull;
for(j = 0;j < i;j++)
main_base *= 10ull;
main_limit = main_base + 2000000000ull;
// set list_size_log2
u32 l;
l = 1 + (u32)ceil(sqrt((double)main_limit));
l = 2 + (l >> _sieve_bits_log2_);
for(list_size_log2 = 2;(1 << list_size_log2) < l;list_size_log2++)
;
//set main_lists
for (int i = 0; i < nthreads;i++) {
available_buckets[i] = NULL;
main_lists[i] = (bucket **)get_memory((1 << list_size_log2) * sizeof(bucket *));
for(u32 k = 0;k < (1 << list_size_log2);k++)
{
main_lists[i][k] = NULL;
new_bucket(k, i);
}
}
//set_small_primes
t = (double)clock();
for (int i = 0; i < nthreads;i++) small_base[i] = 0;
set_small_primes();
printf(" %2d",i);
// init main sieve
init_main_sieve(main_base,0, next_prime, current_list);
t = ((double)clock() - t) / (double)CLOCKS_PER_SEC;
printf(" %6.2f",t);
j = 1 << (_sieve_bits_log2_ - 3);
pi = 0ull;
main_limit = main_base + 1000000000ull;
if(((u32)main_base | (u32)main_limit) & 63)
{
fprintf(stderr,"Warning: prime number counts may be incorrect\n");
fprintf(stderr," main_base and main_limit should be multiples of 64\n");
}
// calculate iteration count fast
t = (double)clock();
u64 main_base_tmp = main_base;
const u64 main_base_const = main_base_tmp;
for(;;)
{
i = (u32)(main_limit - main_base_tmp) >> 4;
if(i <= j)
break;
main_base_tmp += (u64)j << 4;
counter++;
}
{
//prepare values
int th_id = omp_get_thread_num();
u64 main_base_private = main_base_const;
u64 end = main_base_private + (u64)(2 << _sieve_bits_log2_);
u32 next_prime_private = next_prime;
while ((u64) next_prime_private * (u64) next_prime_private < end) next_prime_private += 2;
next_prime = next_prime_private;
// call function
do_main_sieve(main_base_private, th_id, next_prime_private, current_list);
// calculate results
pi += (u64)count_zero_bits((u08 *)main_sieve[th_id],j);
}
while (1) printf("B");
#pragma omp parallel for //private (main_base)
for(u64 c=1;c<counter;c++)
{
//prepare values
u32 current_list_private = current_list;
for (u64 count = 0; count < c; count++)
current_list_private = (current_list_private + 1) & ((1 << list_size_log2) - 1);
int th_id = omp_get_thread_num();
u64 main_base_private = main_base_const+((u64)j << 4)*(c);
u64 end = main_base_const+((u64)j << 4)*(c-1) + (u64)(2 << _sieve_bits_log2_);
u32 next_prime_private = next_prime;
while ((u64) next_prime_private * (u64) next_prime_private < end) next_prime_private += 2;
// call function
do_main_sieve(main_base_private, th_id, next_prime_private, current_list_private);
// calculate results
#pragma omp atomic
pi += (u64)count_zero_bits((u08 *)main_sieve[th_id],j);
printf(" %llu",c);
}
main_base = main_base_const+((u64)j << 4)*(counter);
u64 end = main_base + (u64)(2 << _sieve_bits_log2_);
while ((u64) next_prime * (u64) next_prime < end) next_prime += 2;
for (u64 count = 0; count < counter; count++)
current_list = (current_list + 1) & ((1 << list_size_log2) - 1);
do_main_sieve(main_base, 0, next_prime, current_list);
i = (u32)(main_limit - main_base) >> 4;
pi += (u64)count_zero_bits((u08 *)main_sieve[0],i);
t = ((double)clock() - t) / (double)CLOCKS_PER_SEC;
printf(" %7.2f %8llu\n",t,pi);
return 0;
}
I checked all variables used in this Code, they should be not depending on anything else then the loop variable (and other variables calculated only depending on the loop variable). To be specific
next_prime, main_base, small_base, small_sieve, available_buckets_buckets, main_sieve, current_list should not cause any trouble.
If would really appreciate it if anybody could have a look at it and tell me why I always get the same wrong result if I choose a threadnum > 1.
May some IDE's could tell more about that too but I use Codelite rarely and don't know how to get this information.