Remove atomics from _CHECK_VALIDITY

Author: Fidget-Spinner

Python/bytecodes.c

@@ -3021,7 +3021,7 @@ dummy_func(
 
             _PyExecutorObject *executor = code->co_executors->executors[oparg & 255];
             // We are responsible for cleaning up after ourselves.
-            if (!FT_ATOMIC_LOAD_UINT8_RELAXED(executor->vm_data.valid)) {
+            if (!executor->vm_data.valid) {
                 opcode = executor->vm_data.opcode;
                 oparg = (oparg & ~255) | executor->vm_data.oparg;
                 next_instr = this_instr;
@@ -5289,7 +5289,19 @@ dummy_func(
         }
 
         tier2 op(_CHECK_VALIDITY, (--)) {
-            DEOPT_IF(!FT_ATOMIC_LOAD_UINT8(current_executor->vm_data.valid));
+            // This doesn't need atomics (for now) as there is only a single time
+            // where a write from another thread is possible:
+            // when a new thread is spawned and it invalidates all current
+            // executors.
+            // The new thread can only be created by an executing uop prior to the
+            // _CHECK_VALIDITY check. New thread creation is synchronized by
+            // locking of the runtime, and the current thread is naturally
+            // paused/waiting for the new thread to be created. Thus,
+            // there is a strict happens-before relation between that
+            // uop's invalidation of validity and this check.
+            // So for now, while the JIT does not run on multiple threads,
+            // it is safe for this to be nona-atomic.
+            DEOPT_IF(!current_executor->vm_data.valid);
         }
 
         tier2 pure op(_LOAD_CONST_INLINE, (ptr/4 -- value)) {

Python/executor_cases.c.h

@@ -1504,7 +1504,7 @@ unlink_executor(_PyExecutorObject *executor)
         return;
     }
     _PyExecutorLinkListNode *links = &executor->vm_data.links;
-    assert(FT_ATOMIC_LOAD_UINT8_RELAXED(executor->vm_data.valid) == 0);
+    assert(executor->vm_data.valid == 0);
     _PyExecutorObject *next = links->next;
     _PyExecutorObject *prev = links->previous;
     if (next != NULL) {
@@ -1629,7 +1629,7 @@ static int
 executor_clear(PyObject *op)
 {
     _PyExecutorObject *executor = _PyExecutorObject_CAST(op);
-    assert(FT_ATOMIC_LOAD_UINT8_RELAXED(executor->vm_data.valid) == 0);
+    assert(executor->vm_data.valid == 0);
     unlink_executor(executor);
 
     _PyExecutorObject *cold = _PyExecutor_GetColdExecutor();
@@ -1669,7 +1669,7 @@ invalidate_sub_executors(_PyThreadStateImpl *tstate, _PyExecutorObject *executor
     if (!executor->vm_data.valid) {
         return;
     }
-    FT_ATOMIC_STORE_UINT8(executor->vm_data.valid, 0);
+    executor->vm_data.valid = 0;
     for (uint32_t i = 0; i < executor->exit_count; i++) {
         _PyExecutorObject *next = executor->exits[i].executor;
         if (next != tstate->jit_executor_state.cold_dynamic_executor && next != tstate->jit_executor_state.cold_executor) {
@@ -1729,7 +1729,7 @@ _Py_Executors_InvalidateAllLockHeld(PyInterpreterState *interp, int is_invalidat
         FT_ATOMIC_STORE_UINT8(((_PyThreadStateImpl *)p)->jit_tracer_state.prev_state.dependencies_still_valid, 0);
         for (_PyExecutorObject *exec = ((_PyThreadStateImpl *)p)->jit_executor_state.executor_list_head; exec != NULL;) {
             assert(exec->tstate == p);
-            FT_ATOMIC_STORE_UINT8(exec->vm_data.valid, 0);
+            exec->vm_data.valid = 0;
             // Let it be cleared up by cold executor invalidation later.
             exec->vm_data.warm = 0;
             if (is_invalidation) {
@@ -1768,7 +1768,7 @@ _Py_Executors_CollectCold(PyThreadState *tstate)
         _PyExecutorObject *next = exec->vm_data.links.next;
 
         if (!exec->vm_data.warm || !exec->vm_data.valid) {
-            FT_ATOMIC_STORE_UINT8(exec->vm_data.valid, 0);
+            exec->vm_data.valid = 0;
             if (PyList_Append(invalidate, (PyObject *)exec) < 0) {
                 goto error;
             }