Stackless issue #181: Replace slp_dont_optimize... vars

by more appropriate compiler specific code. The new code should work
with whole program optimisation.

Author: Anselm Kruis

Python/ceval.c

@@ -3854,9 +3854,6 @@ _PyEval_EvalFrameDefault(PyFrameObject *f, int throwflag)
 
 
 #ifdef STACKLESS
-/* a global write only dummy variable */
-char slp_dont_optimise_away_slp_eval_frame_functions;
-
 PyObject * _Py_HOT_FUNCTION
 slp_eval_frame_noval(PyFrameObject *f, int throwflag, PyObject *retval)
 {
@@ -3866,7 +3863,8 @@ slp_eval_frame_noval(PyFrameObject *f, int throwflag, PyObject *retval)
      * it serves as a marker whether we expect a value or
      * not, and it makes debugging a little easier.
      */
-    slp_dont_optimise_away_slp_eval_frame_functions = 1;
+    SLP_DO_NOT_OPTIMIZE_AWAY((char *)1);
+
     r = slp_eval_frame_value(f, throwflag, retval);
     return r;
 }
@@ -3881,7 +3879,7 @@ slp_eval_frame_iter(PyFrameObject *f, int throwflag, PyObject *retval)
      * for_iter operation. In this case we need to handle
      * null without error as valid result.
      */
-    slp_dont_optimise_away_slp_eval_frame_functions = 2;
+    SLP_DO_NOT_OPTIMIZE_AWAY((char *)2);
     r = slp_eval_frame_value(f, throwflag, retval);
     return r;
 }
@@ -3896,7 +3894,7 @@ slp_eval_frame_setup_with(PyFrameObject *f, int throwflag, PyObject *retval)
      * SETUP_WITH operation.
      * NOTE / XXX: see above.
      */
-    slp_dont_optimise_away_slp_eval_frame_functions = 3;
+    SLP_DO_NOT_OPTIMIZE_AWAY((char *)3);
     r = slp_eval_frame_value(f, throwflag, retval);
     return r;
 }
@@ -3911,7 +3909,7 @@ slp_eval_frame_with_cleanup(PyFrameObject *f, int throwflag, PyObject *retval)
      * WITH_CLEANUP operation.
      * NOTE / XXX: see above.
      */
-    slp_dont_optimise_away_slp_eval_frame_functions = 4;
+    SLP_DO_NOT_OPTIMIZE_AWAY((char *)4);
     r = slp_eval_frame_value(f, throwflag, retval);
     return r;
 }

Stackless/core/slp_transfer.c

@@ -50,6 +50,8 @@ or disable the STACKLESS flag.
 #endif
 #include "platf/slp_platformselect.h"
 
+SLP_DO_NOT_OPTIMIZE_AWAY_DEFINITIONS
+
 #ifdef EXTERNAL_ASM
 /* CCP addition: Make these functions, to be called from assembler.
  * The token include file for the given platform should enable the
@@ -85,8 +87,6 @@ extern int slp_switch(void);
 
 #endif
 
-/* a write only variable used to prevent overly optimisation */
-intptr_t *slp_dont_optimise_away_goobledigoobs;
 static int
 climb_stack_and_transfer(PyCStackObject **cstprev, PyCStackObject *cst,
                          PyTaskletObject *prev)
@@ -101,15 +101,14 @@ climb_stack_and_transfer(PyCStackObject **cstprev, PyCStackObject *cst,
     intptr_t probe;
     register ptrdiff_t needed = &probe - ts->st.cstack_base;
     /* in rare cases, the need might have vanished due to the recursion */
-    register intptr_t *goobledigoobs;
     if (needed > 0) {
-        goobledigoobs = alloca(needed * sizeof(intptr_t));
-        if (goobledigoobs == NULL)
+        register void * stack_ptr_tmp = alloca(needed * sizeof(intptr_t));
+        if (stack_ptr_tmp == NULL)
             return -1;
-        /* hinder the compiler to optimise away 
-           goobledigoobs and the alloca call. 
+        /* hinder the compiler to optimise away
+           stack_ptr_tmp and the alloca call.
            This happens with gcc 4.7.x and -O2 */
-        slp_dont_optimise_away_goobledigoobs = goobledigoobs;
+        SLP_DO_NOT_OPTIMIZE_AWAY(stack_ptr_tmp);
     }
     return slp_transfer(cstprev, cst, prev);
 }

Stackless/core/stacklesseval.c

@@ -256,11 +256,14 @@ climb_stack_and_eval_frame(PyFrameObject *f)
     intptr_t probe;
     ptrdiff_t needed = &probe - ts->st.cstack_base;
     /* in rare cases, the need might have vanished due to the recursion */
-    intptr_t *goobledigoobs;
     if (needed > 0) {
-        goobledigoobs = alloca(needed * sizeof(intptr_t));
-        if (goobledigoobs == NULL)
+        register void * stack_ptr_tmp = alloca(needed * sizeof(intptr_t));
+        if (stack_ptr_tmp == NULL)
             return NULL;
+        /* hinder the compiler to optimise away
+        stack_ptr_tmp and the alloca call.
+        This happens with gcc 4.7.x and -O2 */
+        SLP_DO_NOT_OPTIMIZE_AWAY(stack_ptr_tmp);
     }
     return slp_eval_frame(f);
 }

Stackless/module/scheduling.c

@@ -355,7 +355,6 @@ typedef struct {
 /* not a valid ptr and not a common integer */
 #define SAVED_TSTATE_MAGIC1 (((intptr_t)transfer_with_tracing)+1)
 #define SAVED_TSTATE_MAGIC2 (-1*((intptr_t)transfer_with_tracing))
-saved_tstat_with_magic_t * slp_dont_optimise_away_saved_tstat_with_magic;
 
 static int
 transfer_with_tracing(PyCStackObject **cstprev, PyCStackObject *cst, PyTaskletObject *prev)
@@ -370,7 +369,7 @@ transfer_with_tracing(PyCStackObject **cstprev, PyCStackObject *cst, PyTaskletOb
     /* prevent overly compiler optimisation.
     We store the address of sm into a global variable.
     This way the optimizer can't change the layout of the structure. */
-    slp_dont_optimise_away_saved_tstat_with_magic = &sm;
+    SLP_DO_NOT_OPTIMIZE_AWAY(&sm);
 
     sm.s.tracing = ts->tracing;
     sm.s.c_profilefunc = ts->c_profilefunc;

Stackless/platf/slp_platformselect.h

@@ -20,9 +20,9 @@
 #elif defined(__GNUC__) && defined(sparc) && defined(sun)
 #include "switch_sparc_sun_gcc.h" /* SunOS sparc with gcc */
 #elif defined(__GNUC__) && defined(__s390__) && defined(__linux__)
-#include "switch_s390_unix.h"	/* Linux/S390 */
+#include "switch_s390_unix.h"   /* Linux/S390 */
 #elif defined(__GNUC__) && defined(__s390x__) && defined(__linux__)
-#include "switch_s390_unix.h"	/* Linux/S390 zSeries (identical) */
+#include "switch_s390_unix.h"   /* Linux/S390 zSeries (identical) */
 #elif defined(__GNUC__) && defined(__arm__) && defined(__thumb__)
 #include "switch_arm_thumb_gcc.h" /* gcc using arm thumb */
 #elif defined(__GNUC__) && defined(__arm32__)
@@ -35,6 +35,51 @@
 
 /* default definitions if not defined in above files */
 
+/*
+ * Call SLP_DO_NOT_OPTIMIZE_AWAY(pointer) to ensure that pointer will be
+ * computed even post-optimization.  Use it for pointers that are computed but
+ * otherwise are useless. The compiler tends to do a good job at eliminating
+ * unused variables, and this macro fools it into thinking var is in fact
+ * needed.
+ */
+
+#ifndef SLP_DO_NOT_OPTIMIZE_AWAY
+
+/* Code is based on Facebook folly
+ * https://github.com/facebook/folly/blob/master/folly/Benchmark.h,
+ * which has an Apache 2 license.
+ */
+#ifdef _MSC_VER
+
+#pragma optimize("", off)
+
+static inline void doNotOptimizeDependencySink(const void* p) {}
+
+#pragma optimize("", on)
+
+#define SLP_DO_NOT_OPTIMIZE_AWAY(pointer) doNotOptimizeDependencySink(pointer)
+#define SLP_DO_NOT_OPTIMIZE_AWAY_DEFINITIONS /* empty */
+
+#elif (defined(__GNUC__) || defined(__clang__))
+/*
+ * The "r" constraint forces the compiler to make datum available
+ * in a register to the asm block, which means that it must have
+ * computed/loaded it.
+ */
+#define SLP_DO_NOT_OPTIMIZE_AWAY(pointer) \
+    do {__asm__ volatile("" ::"r"(pointer));} while(0)
+#define SLP_DO_NOT_OPTIMIZE_AWAY_DEFINITIONS /* empty */
+#else
+/*
+ * Unknown compiler
+ */
+#define SLP_DO_NOT_OPTIMIZE_AWAY(pointer) \
+    do { slp_do_not_opimize_away_sink = ((void*)(pointer)); } while(0)
+extern uint8_t* volatile slp_do_not_opimize_away_sink;
+#define SLP_DO_NOT_OPTIMIZE_AWAY_DEFINITIONS uint8_t* volatile slp_do_not_opimize_away_sink;
+#endif
+#endif
+
 /* adjust slots to typical size of a few recursions on your system */
 
 #ifndef CSTACK_SLOTS
@@ -82,8 +127,8 @@
 #endif
 
 #define CSTACK_SAVE_NOW(tstate, stackvar) \
-	((tstate)->st.cstack_root != NULL ? \
-	 CSTACK_SUBTRACT((tstate)->st.cstack_root, \
-	 (intptr_t*)&(stackvar)) > CSTACK_WATERMARK : 1)
+        ((tstate)->st.cstack_root != NULL ? \
+         CSTACK_SUBTRACT((tstate)->st.cstack_root, \
+         (intptr_t*)&(stackvar)) > CSTACK_WATERMARK : 1)
 
 #endif