Reland "[wasm] Remove all implications from --predictable"

backes · V8 LUCI CQ · commit dcd078421c7e · 2021-06-08T09:32:37.000Z
This is a reland of 79d63a5. Some fixes landed already, and two tests need to be skipped now (one with a tracking bug). Original change's description: > [wasm] Remove all implications from --predictable > > In predictable mode, we want to execute the same code as otherwise, > modulo timing. Hence remove any implications which change behaviour > (like tier-up or asynchronous compilation). > Note that --predictable is a debugging flag, so the configurations does > not need to "make sense" in production. > > R=ahaas@chromium.org > > Bug: v8:11848 > Change-Id: If74fbacadeb087d977922c41f33fd18738b50ded > Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2940898 > Commit-Queue: Clemens Backes <clemensb@chromium.org> > Reviewed-by: Andreas Haas <ahaas@chromium.org> > Cr-Commit-Position: refs/heads/master@{#74973} Bug: v8:11848 Change-Id: I3564e4351d6545bb9643d1ae44722eb2606b8961 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2944936 Reviewed-by: Andreas Haas <ahaas@chromium.org> Commit-Queue: Clemens Backes <clemensb@chromium.org> Cr-Commit-Position: refs/heads/master@{#75009}
diff --git a/src/flags/flag-definitions.h b/src/flags/flag-definitions.h
@@ -2057,11 +2057,6 @@ DEFINE_IMPLICATION(predictable, single_threaded_gc)
 DEFINE_NEG_IMPLICATION(predictable, concurrent_recompilation)
 DEFINE_NEG_IMPLICATION(predictable, compiler_dispatcher)
 DEFINE_NEG_IMPLICATION(predictable, stress_concurrent_inlining)
-#if V8_ENABLE_WEBASSEMBLY
-DEFINE_VALUE_IMPLICATION(predictable, wasm_num_compilation_tasks, 0)
-DEFINE_NEG_IMPLICATION(predictable, wasm_async_compilation)
-DEFINE_NEG_IMPLICATION(predictable, wasm_tier_up)
-#endif  // V8_ENABLE_WEBASSEMBLY
 
 DEFINE_BOOL(predictable_gc_schedule, false,
             "Predictable garbage collection schedule. Fixes heap growing, "
diff --git a/src/wasm/wasm-engine.cc b/src/wasm/wasm-engine.cc
@@ -208,6 +208,8 @@ std::shared_ptr<NativeModule> NativeModuleCache::MaybeGetNativeModule(
         return shared_native_module;
       }
     }
+    // TODO(11858): This deadlocks in predictable mode, because there is only a
+    // single thread.
     cache_cv_.Wait(&mutex_);
   }
 }
diff --git a/test/mjsunit/mjsunit.status b/test/mjsunit/mjsunit.status
@@ -1092,6 +1092,10 @@
   'regress/wasm/regress-7785': [SKIP],
   'regress/wasm/regress-808848': [SKIP],
   'regress/wasm/regress-808980': [SKIP],
+
+  # BUG(v8:11858): Deadlocks in predictable mode when waiting for the native
+  # module cache entry to be completed.
+  'regress/wasm/regress-709684': [SKIP],
 }],  # 'predictable == True'
 
 ##############################################################################
diff --git a/test/mjsunit/wasm/wasm-dynamic-tiering.js b/test/mjsunit/wasm/wasm-dynamic-tiering.js
@@ -5,6 +5,10 @@
 // Flags: --allow-natives-syntax --wasm-dynamic-tiering --liftoff
 // Flags: --no-wasm-tier-up --no-stress-opt
 
+// This test busy-waits for tier-up to be complete, hence it does not work in
+// predictable more where we only have a single thread.
+// Flags: --no-predictable
+
 d8.file.execute('test/mjsunit/wasm/wasm-module-builder.js');
 
 const num_iterations = 4;
diff --git a/tools/testrunner/local/variants.py b/tools/testrunner/local/variants.py
@@ -81,9 +81,8 @@
 INCOMPATIBLE_FLAGS_PER_BUILD_VARIABLE = {
   "lite_mode": ["--no-lazy-feedback-allocation", "--max-semi-space-size=*"]
                + INCOMPATIBLE_FLAGS_PER_VARIANT["jitless"],
-  "predictable": ["--liftoff", "--parallel-compile-tasks",
+  "predictable": ["--parallel-compile-tasks",
                   "--concurrent-recompilation",
-                  "--wasm-num-compilation-tasks=*",
                   "--stress-concurrent-allocation"],
 }
 

Original file line number	Diff line number	Diff line change
`@@ -208,6 +208,8 @@ std::shared_ptr<NativeModule> NativeModuleCache::MaybeGetNativeModule(`
`208`	`208`	`return shared_native_module;`
`209`	`209`	`}`
`210`	`210`	`}`
	`211`	`+ // TODO(11858): This deadlocks in predictable mode, because there is only a`
	`212`	`+ // single thread.`
`211`	`213`	`cache_cv_.Wait(&mutex_);`
`212`	`214`	`}`
`213`	`215`	`}`