Dear Friends,
I am trying to trace a segfault with valgrind. I get the following message from valgrind:
==3683== Conditional jump or move depends on uninitialised value(s)
==3683== at 0x4C277C5: sparse_mat_mat_kron (sparse.c:165)
==3683== by 0x4C2706E: rec_mating (rec.c:176)
==3683== by 0x401C1C: age_dep_iterate (age_dep.c:287)
==3683== by 0x4014CB: main (age_dep.c:92)
==3683== Uninitialised value was created by a
stack allocation
==3683== at 0x401848: age_dep_init_params (age_dep.c:131)
==3683==
==3683== Conditional jump or move depends on uninitialised value(s)
==3683== at 0x4C277C7: sparse_mat_mat_kron (sparse.c:165)
==3683== by 0x4C2706E: rec_mating (rec.c:176)
==3683== by 0x401C1C: age_dep_iterate (age_dep.c:287)
==3683== by 0x4014CB: main (age_dep.c:92)
==3683== Uninitialised value was created by a
stack allocation
==3683== at 0x401848: age_dep_init_params (age_dep.c:131)
However, here's the offending line:
/* allocate mating table */
age_dep_data->mtable = malloc (age_dep_data->geno * sizeof (double *));
if (age_dep_data->mtable == NULL)
error (ENOMEM, ENOMEM, nullmsg, __LINE__);
for (int j = 0; j < age_dep_data->geno; j++)
{
131=> age_dep_data->mtable[j] = calloc (age_dep_data->geno, sizeof (double));
if (age_dep_data->mtable[j] == NULL)
error (ENOMEM, ENOMEM, nullmsg, __LINE__);
}
What gives? I thought any call to malloc or calloc allocated heap space; there is no other variable allocated here, right? Is it possible there's another allocation going on (the offending
stack allocation) that I'm not seeing?
You asked to see the code, here goes:
/*
Copyright 2010 Joel J. Adamson <
[email protected]>
$Id: age_dep.c 1010 2010-04-21 19:19:16Z joel $
age_dep.c:main file
Joel J. Adamson -- http://www.unc.edu/~adamsonj
Servedio Lab
University of North Carolina at Chapel Hill
CB #3280, Coker Hall
Chapel Hill, NC 27599-3280
This file is part of an investigation of age-dependent sexual
selection.
This code 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 3 of the License, or
(at your option) any later version.
This software 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 haploid. If not, see <http://www.gnu.org/licenses/>.
*/
#include "age_dep.h"
/* global variables */
extern struct argp age_dep_argp;
/* global error message variables */
char * nullmsg = "Null pointer: %i";
/* error message for conversions: */
char * errmsg = "Representation error: %s";
/* precision for formatted output: */
const char prec[] = "%-#9.8f ";
const size_t age_max = AGEMAX; /* maximum age of males */
static int keep_going_p = 1;
int
main (int argc, char ** argv)
{
/* often used counters: */
int i, j;
/* read the command line */
struct age_dep_args age_dep_args = { NULL, NULL, NULL };
argp_parse (&age_dep_argp, argc, argv, 0, 0, &age_dep_args);
/* set the parameters here: */
/* initialize an age_dep_params structure, set the members */
age_dep_params_t * params = malloc (sizeof (age_dep_params_t));
if (params == NULL)
error (ENOMEM, ENOMEM, nullmsg, __LINE__);
age_dep_init_params (params, &age_dep_args);
/* initialize frequencies: this initializes a list of pointers to
initial frqeuencies, terminated by a NULL pointer*/
params->freqs = age_dep_init (&age_dep_args);
params->by = 0.0;
/* what range of parameters do we want, and with what stepsize? */
/* we should go from 0 to half-of-theta with a step size of about
0.01 */
double from = 0.0;
double to = params->theta / 2.0;
double stepsz = 0.01; /* did you think I would spell the
whole word? */
unsigned int numparts = floor(to / stepsz);
do
{
#pragma omp parallel for private(i) firstprivate(params) \
shared(stepsz, numparts)
for (i = 0; i < numparts; i++)
{
params->by = i * stepsz;
int tries = 0;
while (keep_going_p)
{
/* each time through, modify mfreqs and mating table, then go
again */
keep_going_p = age_dep_iterate (params, ++tries);
if (keep_going_p == ERANGE)
error (ERANGE, ERANGE, "Failure to converge\n");
}
fprintf (stdout, "%i iterations\n", tries);
} /* for i < numparts */
params->freqs = params->freqs->next;
} while (params->freqs->next != NULL);
return 0;
}
inline double
age_dep_pmate (double age_dep_t, unsigned int genot, double bp, double ba)
{
/* the probability of mating between these phenotypes */
/* the female preference depends on whether the female has the
preference allele, the strength of preference (parameter bp) and
the male phenotype (age_dep_t); if the female lacks the
preference allele, then this will return 0, which is not quite
accurate; it should return 1 */
return bits_isset (genot, CLOCI)?
1.0 - exp (-bp * age_dep_t) + ba:
1.0;
}
inline double
age_dep_trait (int age, unsigned int genot, double by)
{
/* return the male trait, a function of the trait locus, age, the
age-dependent scaling parameter (bx) and the males condition
genotype */
double C;
double T;
/* get the male's condition genotype */
C = (double) bits_popcount (bits_extract (0, CLOCI, genot));
/* get his trait genotype */
T = bits_isset (genot, CLOCI + 1)? 1.0: 0.0;
/* return the trait value */
return T * by * exp (age * C);
}
int
age_dep_iterate (age_dep_params_t * data, unsigned int tries)
{
/* main driver routine */
/* number of bytes for female frequencies */
size_t geno = data->age_dep_data->geno;
size_t genosize = geno * sizeof (double);
/* female frequencies are equal to male frequencies at birth (before
selection) */
double ffreqs[geno];
if (ffreqs == NULL)
error (ENOMEM, ENOMEM, nullmsg, __LINE__);
/* do not set! Use memcpy (we need to alter male frequencies
(selection) without altering female frequencies) */
memmove (ffreqs, data->freqs->freqs[0], genosize);
/* for (int i = 0; i < geno; i++) */
/* ffreqs[i] = data->freqs->freqs[0][i]; */
#ifdef PRMTABLE
age_dep_pr_mfreqs (data);
#endif /* PRMTABLE */
/* natural selection: */
age_dep_ns (data);
/* normalized mating table with new frequencies */
age_dep_norm_mtable (ffreqs, data);
#ifdef PRMTABLE
age_dep_pr_mtable (data);
#endif /* PRMTABLE */
double * newfreqs;
/* mutate here */
/* i.e. get the new frequency of 0-year-olds using
recombination; */
newfreqs = rec_mating (data->age_dep_data);
/* return block */
{
if (sim_stop_ck (data->freqs->freqs[0], newfreqs, GENO, TOL) == 0)
{
/* if we have converged, stop the iterations and handle the data */
age_dep_sim_out (data, stdout);
return 0;
}
else if (tries > MAXTRIES)
return ERANGE;
else
{
/* advance generations */
for (int j = age_max - 1; j < 0; j--)
memmove (data->freqs->freqs[j],
data->freqs->freqs[j-1],
genosize);
/* advance the first age-class */
memmove (data->freqs->freqs[0], newfreqs, genosize);
return 1;
}
}
}
void
age_dep_ns (age_dep_params_t * data)
{
/* calculate the new frequency of genotypes given additive fitness
and selection coefficient s */
size_t geno = data->age_dep_data->geno;
double w[geno];
double wbar, dtheta, ttheta, dcond, tcond;
double t, cond;
/* fitness parameters */
double mu, nu;
mu = data->wparams[0];
nu = data->wparams[1];
/* calculate fitness */
for (int j = 0; j < age_max; j++)
{
int i;
for (i = 0; i < geno; i++)
{
/* calculate male trait: */
t = age_dep_trait(j, i, data->by);
/* calculate condition: */
cond = (double) bits_popcount (bits_extract(0, CLOCI, i));
/* trait-based fitness term */
dtheta = data->theta - t;
ttheta = (dtheta * dtheta) / (2.0 * nu * nu);
/* condition-based fitness term */
dcond = CLOCI - cond;
tcond = (dcond * dcond) / (2.0 * mu * mu);
/* calculate male fitness */
w[i] = 1 + exp(-tcond) - exp(-ttheta);
}
/* calculate mean fitness */
/* as long as we calculate wbar before altering any values of
freqs[], we're safe */
wbar = gen_mean (data->freqs->freqs[j], w, geno);
for (i = 0; i < geno; i++)
data->freqs->freqs[j][i] =
(data->freqs->freqs[j][i] * w[i]) / wbar;
}
}
void
age_dep_norm_mtable (double * ffreqs, age_dep_params_t * params)
{
/* this function produces a single mating table that forms the input
for recombination () */
/* i is female genotype; j is male genotype; k is male age */
int i,j,k;
double norm_denom;
double trait;
size_t geno = params->age_dep_data->geno;
for (i = 0; i < geno; i++)
{
double norm_mtable[geno];
/* initialize the denominator: */
norm_denom = 0.0;
/* find the probability of mating and add it to the denominator */
for (j = 0; j < geno; j++)
{
/* initialize entry: */
norm_mtable[j] = 0.0;
for (k = 0; k < age_max; k++)
{
trait = age_dep_trait (k, j, params->by);
norm_mtable[j] +=
age_dep_pmate (trait, i, params->bp, params->ba)
* (params->freqs->freqs)[k][j];
}
norm_denom += norm_mtable[j];
}
/* now calculate entry (i,j) */
for (j = 0; j < geno; j++)
params->age_dep_data->mtable[i][j]
= (ffreqs[i] * norm_mtable[j]) / norm_denom;
}
}
My current suspicion is the array newfreqs: I can't memmove, memcpy or assign a
stack variable then hope it will persist, can I? rec_mating() returns double *.
