detect stochastic mutationEffect() callbacks to disable DEBUG crosschecks

Author: bhaller

core/individual.cpp

@@ -7398,6 +7398,9 @@ void Individual_Class::DemandPhenotype_INDIVIDUALS(Species *species, Individual
 	SLiMEidosBlockType old_executing_block_type = species->community_.executing_block_type_;
 	species->community_.executing_block_type_ = SLiMEidosBlockType::SLiMEidosMutationEffectCallback;
 
+	// In DEBUG we will watch for RNG usage and disable trait value crosschecks if stochastic callbacks are involved
+	EIDOS_RNG_PING_RESET();
+	
 	// Calculate the specified phenotypes for the individuals; this loops through all chromosomes, handling
 	// ploidy and callbacks as needed.  It is very nice to have the top-level loop be over the chromosomes,
 	// so that each one can do a single timing for mutrun experiments.
@@ -7609,7 +7612,10 @@ void Individual_Class::DemandPhenotype_INDIVIDUALS(Species *species, Individual
 
 #if DEBUG
 	// Do a check of all computed results, against the same values computed by brute force.
-	// FIXME MULTITRAIT: Since this is incorrect with stochastic callbacks, it should be turned into a warning before ship
+	// If we noticed RNG use during trait calculations, we turn off these crosschecks.
+	if (EIDOS_RNG_PING_IS_SET())
+		gSLiM_disable_trait_crosschecks = true;
+	
 	if (gSLiM_disable_trait_crosschecks)
 		return;
 
@@ -7850,6 +7856,9 @@ void Individual_Class::DemandPhenotype_SUBPOP(Species *species, Subpopulation *s
 	SLiMEidosBlockType old_executing_block_type = species->community_.executing_block_type_;
 	species->community_.executing_block_type_ = SLiMEidosBlockType::SLiMEidosMutationEffectCallback;
 
+	// In DEBUG we will watch for RNG usage and disable trait value crosschecks if stochastic callbacks are involved
+	EIDOS_RNG_PING_RESET();
+	
 	// Calculate the specified phenotypes for the individuals; this loops through all chromosomes, handling
 	// ploidy and callbacks as needed.  It is very nice to have the top-level loop be over the chromosomes,
 	// so that each one can do a single timing for mutrun experiments.
@@ -8243,7 +8252,10 @@ void Individual_Class::DemandPhenotype_SUBPOP(Species *species, Subpopulation *s
 
 #if DEBUG
 	// Do a check of all computed results, against the same values computed by brute force.
-	// FIXME MULTITRAIT: Since this is incorrect with stochastic callbacks, it should be turned into a warning before ship
+	// If we noticed RNG use during trait calculations, we turn off these crosschecks.
+	if (EIDOS_RNG_PING_IS_SET())
+		gSLiM_disable_trait_crosschecks = true;
+	
 	if (gSLiM_disable_trait_crosschecks)
 		return;
 

core/slim_globals.cpp

@@ -628,7 +628,7 @@ void AccumulateMemoryUsageIntoTotal_Community(SLiMMemoryUsage_Community &p_usage
 #pragma mark Debugging support
 #pragma mark -
 
-bool gSLiM_disable_trait_crosschecks = false;;
+bool gSLiM_disable_trait_crosschecks = false;
 
 
 #pragma mark -

core/slim_globals.h

@@ -549,7 +549,10 @@ void AccumulateMemoryUsageIntoTotal_Community(SLiMMemoryUsage_Community &p_usage
 extern int64_t SLiM_verbosity_level;
 
 // This flag can be set to true to disable trait value crosschecks; this is necessary in some cases if stochastic
-// mutationEffect() callbacks are in effect, or if phenotype values are being set directly by the script.
+// mutationEffect() callbacks are in effect, or if phenotype values are being set directly by the script.  This
+// flag will stay on if set, except that it is reset to false in _SLiMTestCleanup().  It is automatically set
+// to true if stochastic mutationEffect() callbacks are detected, but that does not cover all possible cases, so
+// false positives from the trait crosschecks may be observed in DEBUG builds, which is why this flag exists.
 extern bool gSLiM_disable_trait_crosschecks;
 
 

core/slim_test.cpp

@@ -57,6 +57,8 @@ static void _SLiMTestCleanup(Community *community)
 		std::cerr << "WARNING (SLiMAssertScriptSuccess): gEidos_DictionaryNonRetainReleaseReferenceCounter == " << gEidos_DictionaryNonRetainReleaseReferenceCounter << " at end of test!" << std::endl;
 
 	gEidos_DictionaryNonRetainReleaseReferenceCounter = 0;
+	
+	gSLiM_disable_trait_crosschecks = false;
 }
 
 // Instantiates and runs the script, and prints an error if the result does not match expectations

core/slim_test_genetics.cpp

@@ -2857,8 +2857,6 @@ reproduction() { }
 
 	// this script tests invalidation of trait values when a non-constant mutationEffect() callback is active
 	// - trait values in all individuals should be invalidated at the start of each demand phase
-	gSLiM_disable_trait_crosschecks = true;	// crosschecks don't like the stochastic callback here!
-	
 	#pragma mark multitrait_INVALIDATE_8
 	std::string multitrait_INVALIDATE_8 =
 		R"V0G0N(
@@ -2905,8 +2903,6 @@ mutationEffect(m1) { return runif(1, 0.01, 0.99); }
 
 	SLiMAssertScriptSuccess(multitrait_INVALIDATE_8);
 
-	gSLiM_disable_trait_crosschecks = false;	// resume crosschecks
-	
 
 	// this script tests invalidation of trait values when a mutationEffect() callback comes in and out
 	// of scope, is registered/deregistered, is rescheduled, or is activated/deactivated

eidos/eidos_rng.cpp

@@ -84,6 +84,10 @@ Eidos_RNG_State gEidos_RNG_SINGLE;
 std::vector<Eidos_RNG_State *> gEidos_RNG_PERTHREAD;
 #endif
 
+#if DEBUG
+bool gEidos_RNG_usageFlag = false;	// see the header for comments
+#endif
+
 
 static unsigned long int _Eidos_GenerateRNGSeed(void)
 {

eidos/eidos_rng.h

@@ -99,7 +99,25 @@ extern Eidos_RNG_State gEidos_RNG_SINGLE;
 extern std::vector<Eidos_RNG_State *> gEidos_RNG_PERTHREAD;
 #endif
 
-// Calls to the GSL should use these macros to get the RNG state they need, whether single- or multi-threaded.
+#if DEBUG
+// This global flag is a bit of a hack.  It's a way for Eidos client code to detect when the random number
+// generator has been used by the Eidos interpreter, which might be of interest.  SLiM uses this to disable
+// some checks that are invalid if the Eidos code executed is stochastic.  This is NOT thread-safe, in the
+// sense that if different threads are try to use this facility simultaneously it will not work.  It is
+// also just hacky enough that it probably shouldn't be used in production code, so it is DEBUG only.
+// The flag is set whenever one of the RNG accessors below is called.
+extern bool gEidos_RNG_usageFlag;
+
+inline __attribute__((always_inline)) void EIDOS_RNG_PING_RESET(void) { gEidos_RNG_usageFlag = false; }
+inline __attribute__((always_inline)) void EIDOS_RNG_PING(void) { gEidos_RNG_usageFlag = true; }
+inline __attribute__((always_inline)) bool EIDOS_RNG_PING_IS_SET(void) { return gEidos_RNG_usageFlag; }
+#else
+inline __attribute__((always_inline)) void EIDOS_RNG_PING_RESET(void) { }
+inline __attribute__((always_inline)) void EIDOS_RNG_PING(void) { }
+inline __attribute__((always_inline)) bool EIDOS_RNG_PING_IS_SET(void) { return false; }
+#endif
+
+// Calls to the GSL should use these functions to get the RNG state they need, whether single- or multi-threaded.
 // BCH 11/5/2022: The thread number must now be supplied.  It will be zero when single-threaded, and so is
 // ignored.  Since this is now a bit more heavyweight, the RNG for a thread should be obtained outside of any
 // core loops.  The most important thing is that when there is a parallel region, the RNG is obtained INSIDE
@@ -111,15 +129,15 @@ extern std::vector<Eidos_RNG_State *> gEidos_RNG_PERTHREAD;
 //	Eidos_RNG_State *rng_state = EIDOS_STATE_RNG(omp_get_thread_num());
 //
 #ifndef _OPENMP
-#define EIDOS_GSL_RNG(threadnum)	(&gEidos_RNG_SINGLE.gsl_rng_)
-#define EIDOS_32BIT_RNG(threadnum)	(gEidos_RNG_SINGLE.pcg32_rng_)
-#define EIDOS_64BIT_RNG(threadnum)	(gEidos_RNG_SINGLE.pcg64_rng_)
-#define EIDOS_STATE_RNG(threadnum)	(&gEidos_RNG_SINGLE)
+inline __attribute__((always_inline)) gsl_rng *EIDOS_GSL_RNG(int threadnum)				{ EIDOS_RNG_PING(); return &gEidos_RNG_SINGLE.gsl_rng_; }
+inline __attribute__((always_inline)) EidosRNG_32_bit &EIDOS_32BIT_RNG(int threadnum)	{ EIDOS_RNG_PING(); return gEidos_RNG_SINGLE.pcg32_rng_; }
+inline __attribute__((always_inline)) EidosRNG_64_bit &EIDOS_64BIT_RNG(int threadnum)	{ EIDOS_RNG_PING(); return gEidos_RNG_SINGLE.pcg64_rng_; }
+inline __attribute__((always_inline)) Eidos_RNG_State *EIDOS_STATE_RNG(int threadnum)	{ EIDOS_RNG_PING(); return &gEidos_RNG_SINGLE; }
 #else
-#define EIDOS_GSL_RNG(threadnum)	(&gEidos_RNG_PERTHREAD[threadnum]->gsl_rng_)
-#define EIDOS_32BIT_RNG(threadnum)	(gEidos_RNG_PERTHREAD[threadnum]->pcg32_rng_)
-#define EIDOS_64BIT_RNG(threadnum)	(gEidos_RNG_PERTHREAD[threadnum]->pcg64_rng_)
-#define EIDOS_STATE_RNG(threadnum)	(gEidos_RNG_PERTHREAD[threadnum])
+inline __attribute__((always_inline)) gsl_rng *EIDOS_GSL_RNG(int threadnum)				{ EIDOS_RNG_PING(); return &gEidos_RNG_PERTHREAD[threadnum]->gsl_rng_; }
+inline __attribute__((always_inline)) EidosRNG_32_bit &EIDOS_32BIT_RNG(int threadnum)	{ EIDOS_RNG_PING(); return gEidos_RNG_PERTHREAD[threadnum]->pcg32_rng_; }
+inline __attribute__((always_inline)) EidosRNG_64_bit &EIDOS_64BIT_RNG(int threadnum)	{ EIDOS_RNG_PING(); return gEidos_RNG_PERTHREAD[threadnum]->pcg64_rng_; }
+inline __attribute__((always_inline)) Eidos_RNG_State *EIDOS_STATE_RNG(int threadnum)	{ EIDOS_RNG_PING(); return &gEidos_RNG_PERTHREAD[threadnum]; }
 #endif
 
 #if DEBUG