Segmentation Faults with OPEN MP and pointer operations - c

Question

I'm developing a code to simulate the response of some dynamical systems to my PhD research. To this end, I'm trying to implement parallelization with OpenMP to increase the performance of the code.
Basically I have a solution function parallel_dynamical_diagram_solution that calls other functions within the same file (realloc_vector, perturb_wolf, rk4, lyapunov_wolf, store_LE, get_attractor) that contains some operations and numerical methods. Also, the solution functions calls a pointer to a function edosys that is declared in another file. The solution function is shown below:
void parallel_dynamical_diagram_solution(int dim, int np, int ndiv, int trans, int *attrac, int maxper, double t, double **x, double *varparX, double *varparY, double *parrange, double *par, void (*edosys)(int, double *, double, double *, double *), int bifmode) {
// Allocate memory for x` = f(x)
double *f = malloc(dim * sizeof *f);
// Allocate memory for vectors necessary for lyapunov exponents calculation
double *cum = malloc(dim * sizeof *cum); // Cumulative Vector
double *lambda = malloc(dim *sizeof *lambda); // Lyapunov Exponents vector
double *s_cum = malloc(dim * sizeof *s_cum); // Short Cumulative Vector
double *s_lambda = malloc(dim * sizeof *s_lambda); // Short Lyapunov Exponents Vector
double *znorm = malloc(dim * sizeof *znorm); // Norm of Vectors
double *gsc = malloc((dim - 1) * sizeof *gsc); // Inner Products Vector
// Store Initial Conditions
double t0 = t;
double *IC = malloc(dim * sizeof *IC);
for (int i = 0; i < dim; i++) {
IC[i] = (*x)[i];
}
// Declare rk4 timestep, final time, short initial time and pi
double h, tf, s_T0;
const double pi = 4 * atan(1); // Pi number definition
// Declare and define increment of control parameters
double varstep[2];
varstep[0] = (parrange[1] - parrange[0])/(parrange[2] - 1); // -1 in the denominator ensures the input resolution
varstep[1] = (parrange[4] - parrange[3])/(parrange[5] - 1); // -1 in the denominator ensures the input resolution
// Numerical control parameters
int ndim = dim + (dim * dim); // Define new dimension to include linearized dynamical equations
// Declare vector and allocate memory to store poincare map values: poinc[number of permanent regime forcing periods][dimension original system]
double **poinc = malloc((np - trans) * sizeof **poinc);
for (int i = 0; i < np - trans; i++) {
poinc[i] = malloc(dim * sizeof **poinc);
}
// Declare vector to store the chosen Lyapunov Exponents to determine the attractor
double *LE = malloc(dim * sizeof *LE);
// Declare vector for temporary storage of periodicity values to check if all directions are equal
int *tmp_attrac = malloc(dim * sizeof *tmp_attrac);
// Declare variable to flag if all directions present same periodicity or not (0 = all the same, 1 = not the same)
int diffAttrac = -1;
// Prepare x vector to include perturbed values
realloc_vector(x, ndim);
// Starts the parallel block
int k;
#pragma omp parallel default(none) firstprivate(x, t, par, IC, varstep, diffAttrac, poinc, varparY, varparX) \
private(k, f, attrac, lambda, s_lambda, LE, cum, s_cum, znorm, gsc, h, tf, s_T0, tmp_attrac, edosys) \
shared(parrange, dim, ndim, np, ndiv, trans, t0, bifmode, maxper)
{
// Starts to increment bifurcation control parameter
#pragma omp for schedule(static)
// Loop for Y control parameter
for (k = 0; k < (int)parrange[5]; k++) {
// Value of Y control parameter based on index k
(*varparY) = parrange[3] + k*varstep[1];
printf("(Iteration: %d) varparY = %lf\n", k, (*varparY));
// Reset Initial conditions for the beggining of a horizontal line
for (int i = 0; i < dim; i++) {
(*x)[i] = IC[i];
printf("(Iteration: %d) x[%d] = %lf\n", k, i, (*x)[i]);
}
// Loop for X control parameter
for (int m = 0; m < (int)parrange[2]; m++) {
// Value of X control parameter based on index m
(*varparX) = parrange[0] + m*varstep[0];
printf("(Iteration: %d) a\n", k);
// Reset Variables
t = t0;
printf("(Iteration: %d) b\n", k);
for (int i = 0; i < dim; i++) {
lambda[i] = 0.0;
s_lambda[i] = 0.0;
LE[i] = 0.0;
printf("(Iteration: %d) c\n", k);
}
// Check the mode of the bifurcation
if (bifmode == 1) {
// Reset Initial conditions in each bifurcation step
for (int i = 0; i < dim; i++) {
(*x)[i] = IC[i];
}
}
// Vary timestep if varpar = par[0], varying also final time and short initial time
h = (2 * pi) / (ndiv * par[0]); // par[0] = OMEGA
tf = h*np*ndiv; // Final time
s_T0 = ((double) trans/ (double) np) * tf; // Advanced initial time
// Assign initial perturbation
perturb_wolf(x, dim, ndim, &cum, &s_cum);
// Call Runge-Kutta 4th order integrator N = nP * nDiv times
for (int i = 0; i < np; i++) {
for (int j = 0; j < ndiv; j++) {
rk4(ndim, *x, t, h, par, f, edosys);
lyapunov_wolf(x, t, h, dim, ndim, s_T0, &cum, &s_cum, &lambda, &s_lambda, &znorm, &gsc);
t = t + h;
// Apply poincare map at permanent regime
if (i >= trans) {
// Choose any point in the trajectory for poincare section placement
if (j == 1) {
// Stores poincare values in poinc[np - trans][dim] vector
for (int p = 0; p < dim; p++) {
poinc[i - trans][p] = (*x)[p];
}
}
}
}
}
// Define which lyapunov will be taken: lambda[dim] or s_lambda[dim]
store_LE(dim, lambda, s_lambda, LE);
// Verify the type of motion of the system
(*attrac) = get_attractor(poinc, LE, dim, np, trans, tmp_attrac, &diffAttrac, maxper);
printf("[k = %d] [m = %d]: Attractor = %d, lambda_1 = %lf, lambda_2 = %lf\n",k, m, (*attrac), lambda[0], lambda[1]);
}
}
// Free memory
free(f); free(cum); free(s_cum); free(lambda); free(s_lambda);
free(znorm); free(gsc); free(LE); free(tmp_attrac); free(IC);
for (int i = 0; i < np - trans; i++) {
free(poinc[i]);
}
free(poinc);
} // Ends Parallel Block
}
When I run the code, a segmentation fault error occurs as shown below:
(Iteration: 0) varparY = 0.010000
(Iteration: 0) x[0] = 1.000000
(Iteration: 0) x[1] = 0.000000
(Iteration: 0) a
(Iteration: 0) b
zsh: segmentation fault ./dyndiag
It appears to be happening when I assign the values of lambda, s_lambda and LE, but I don't know why as these variables are declared as private. I'm new to OpenMP and parallelization in general, could someone help me? What am I missing here?
Thanks in advance!

Answer 1

The easy part is to tell why you get segmentation faults: many of your variables are unitialized inside the parallel block (attrac, lambda, s_lambda, LE, cum, s_cum, gsc, etc). Consider the following code segment:
double *lambda = malloc(dim *sizeof *lambda);
#pragma omp parallel private(lambda)
{
lambda[0]=0; // lambda is unitialized --> undefined behavior
}
The private clause makes the pointer private, but will not initialize your private variable or allocate memory for each thread. The code above practically means the following (it may be easier to understand actually what is happening):
double *lambda = malloc(dim *sizeof *lambda);
#pragma omp parallel
{
double* lambda; // a local variable is created for each thread
lambda[0]=0; // BUT it is unitialized --> undefined behavior
}
The solution is to allocate (and free) the memory inside the parallel block:
#pragma omp parallel
{
double *lambda = malloc(dim *sizeof *lambda);
....
lambda[0]=0; // lambda is private and initialized -- OK
...
free(lambda);
}
This will solve your segmentation fault problem, but unfortunately your code will not work properly. You still have issues with your firstprvate variables, but the biggest problem is that you wish to parallelize iterations. As far as I understand your code the output of an iteration is the input of the next one. You simply cannot parallelize it, iteration is a sequential process. You should first read a decent book on OpenMP then rewrite your code and parallelize work inside an iteration.