}
-RUNTIME_FUNCTION(MaybeObject*, Runtime_CompleteOptimization) {
+RUNTIME_FUNCTION(MaybeObject*, Runtime_GetOptimizationStatus) {
HandleScope scope(isolate);
- ASSERT(args.length() == 1);
+ RUNTIME_ASSERT(args.length() == 1 || args.length() == 2);
+ if (!V8::UseCrankshaft()) {
+ return Smi::FromInt(4); // 4 == "never".
+ }
+ bool sync_with_compiler_thread = true;
+ if (args.length() == 2) {
+ CONVERT_ARG_HANDLE_CHECKED(String, sync, 1);
+ if (sync->IsOneByteEqualTo(STATIC_ASCII_VECTOR("no sync"))) {
+ sync_with_compiler_thread = false;
+ }
+ }
CONVERT_ARG_HANDLE_CHECKED(JSFunction, function, 0);
- if (FLAG_parallel_recompilation && V8::UseCrankshaft()) {
- // While function is in optimization pipeline, it is marked accordingly.
- // Note that if the debugger is activated during parallel recompilation,
- // the function will be marked with the lazy-recompile builtin, which is
- // not related to parallel recompilation.
+ if (FLAG_parallel_recompilation && sync_with_compiler_thread) {
while (function->IsMarkedForParallelRecompilation() ||
function->IsInRecompileQueue() ||
function->IsMarkedForInstallingRecompiledCode()) {
OS::Sleep(50);
}
}
- return isolate->heap()->undefined_value();
-}
-
-
-RUNTIME_FUNCTION(MaybeObject*, Runtime_GetOptimizationStatus) {
- HandleScope scope(isolate);
- ASSERT(args.length() == 1);
- if (!V8::UseCrankshaft()) {
- return Smi::FromInt(4); // 4 == "never".
- }
- CONVERT_ARG_HANDLE_CHECKED(JSFunction, function, 0);
- if (FLAG_parallel_recompilation) {
- if (function->IsMarkedForLazyRecompilation()) {
- return Smi::FromInt(5); // 5 == "parallel recompilation".
- }
- }
if (FLAG_always_opt) {
// We may have always opt, but that is more best-effort than a real
// promise, so we still say "no" if it is not optimized.
F(IsParallelRecompilationSupported, 0, 1) \
F(OptimizeFunctionOnNextCall, -1, 1) \
F(NeverOptimizeFunction, 1, 1) \
- F(CompleteOptimization, 1, 1) \
- F(GetOptimizationStatus, 1, 1) \
+ F(GetOptimizationStatus, -1, 1) \
F(GetOptimizationCount, 1, 1) \
F(CompileForOnStackReplacement, 1, 1) \
F(AllocateInNewSpace, 1, 1) \
// No de-opt will occur because HCallNewArray wasn't selected, on account of
// the call site not being monomorphic to Array.
instanceof_check(Array);
- assertTrue(2 != %GetOptimizationStatus(instanceof_check));
+ assertOptimized(instanceof_check);
instanceof_check(realmBArray);
- assertTrue(2 != %GetOptimizationStatus(instanceof_check));
+ assertOptimized(instanceof_check);
// Try to optimize again, but first clear all type feedback, and allow it
// to be monomorphic on first call. Only after crankshafting do we introduce
instanceof_check(Array);
%OptimizeFunctionOnNextCall(instanceof_check);
instanceof_check(Array);
- assertTrue(2 != %GetOptimizationStatus(instanceof_check));
+ assertOptimized(instanceof_check);
instanceof_check(realmBArray);
- assertTrue(1 != %GetOptimizationStatus(instanceof_check));
+ assertUnoptimized(instanceof_check);
}
test_base(dictionary_map_array, 6, false);
%OptimizeFunctionOnNextCall(test_base);
test_base(dictionary_map_array, -2, true);
-assertTrue(%GetOptimizationStatus(test_base) != 1);
+assertUnoptimized(test_base);
// Forget about the dictionary_map_array's map.
%ClearFunctionTypeFeedback(test_base);
test_base(a, 6, false);
%OptimizeFunctionOnNextCall(test_base);
test_base(a, 2048, true);
-assertTrue(%GetOptimizationStatus(test_base) != 1);
+assertUnoptimized(test_base);
function test_minus(base,cond) {
a[base - 1] = 1;
%OptimizeFunctionOnNextCall(short_test);
short_a.length = 10;
short_test(short_a, 0);
-assertTrue(%GetOptimizationStatus(short_test) != 1);
+assertUnoptimized(test_base);
// A test for when we would modify a phi index.
%OptimizeFunctionOnNextCall(bar0);
b = bar0(Array);
assertKind(elements_kind.fast_double, b);
- assertTrue(2 != %GetOptimizationStatus(bar0));
+ assertOptimized(bar0);
// bar0 should deopt
b = bar0(Object);
- assertTrue(1 != %GetOptimizationStatus(bar0));
+ assertUnoptimized(bar0)
// When it's re-optimized, we should call through the full stub
bar0(Array);
%OptimizeFunctionOnNextCall(bar0);
// We also lost our ability to record kind feedback, as the site
// is megamorphic now.
assertKind(elements_kind.fast_smi_only, b);
- assertTrue(2 != %GetOptimizationStatus(bar0));
+ assertOptimized(bar0);
b[0] = 3.5;
c = bar0(Array);
assertKind(elements_kind.fast_smi_only, c);
%OptimizeFunctionOnNextCall(bar);
a = bar(10);
assertKind(elements_kind.fast, a);
- assertTrue(2 != %GetOptimizationStatus(bar));
+ assertOptimized(bar);
// The stub bails out, but the method call should be fine.
a = bar(100000);
- assertTrue(2 != %GetOptimizationStatus(bar));
+ assertOptimized(bar);
assertKind(elements_kind.dictionary, a);
// If the argument isn't a smi, it bails out as well
a = bar("oops");
- assertTrue(2 != %GetOptimizationStatus(bar));
+ assertOptimized(bar);
assertKind(elements_kind.fast, a);
function barn(one, two, three) {
barn(1, 2, 3);
%OptimizeFunctionOnNextCall(barn);
barn(1, 2, 3);
- assertTrue(2 != %GetOptimizationStatus(barn));
+ assertOptimized(barn);
a = barn(1, "oops", 3);
// The stub should bail out but the method should remain optimized.
assertKind(elements_kind.fast, a);
- assertTrue(2 != %GetOptimizationStatus(barn));
+ assertOptimized(barn);
})();
b = bar();
// This only makes sense to test if we allow crankshafting
if (4 != %GetOptimizationStatus(bar)) {
- assertTrue(2 != %GetOptimizationStatus(bar));
+ assertOptimized(bar);
%DebugPrint(3);
b[0] = 3.5;
c = bar();
assertKind(elements_kind.fast_smi_only, c);
- assertTrue(2 != %GetOptimizationStatus(bar));
+ assertOptimized(bar);
}
})();
b[0] = 3.5;
c = create0();
assertKind(elements_kind.fast_double, c);
- assertTrue(2 != %GetOptimizationStatus(create0));
+ assertOptimized(create0);
}
})();
get_literal(3);
%OptimizeFunctionOnNextCall(get_literal);
a = get_literal(3);
- assertTrue(2 != %GetOptimizationStatus(get_literal));
+ assertOptimized(get_literal);
assertTrue(%HasFastSmiElements(a));
a[0] = 3.5;
b = get_literal(3);
assertTrue(%HasFastDoubleElements(b));
assertEquals([1, 2, 3], b);
- assertTrue(1 != %GetOptimizationStatus(get_literal));
+ assertUnoptimized(get_literal);
// Optimize again
get_literal(3);
%OptimizeFunctionOnNextCall(get_literal);
b = get_literal(3);
assertTrue(%HasFastDoubleElements(b));
- assertTrue(2 != %GetOptimizationStatus(get_literal));
+ assertOptimized(get_literal);
}
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// Flags: --allow-natives-syntax --smi-only-arrays --expose-gc
-// Flags: --noparallel-recompilation
// Test element kind of objects.
// Since --smi-only-arrays affects builtins, its default setting at compile
deopt_array(false);
%OptimizeFunctionOnNextCall(deopt_array);
var array = deopt_array(false);
- assertTrue(2 != %GetOptimizationStatus(deopt_array));
+ assertOptimized(deopt_array);
deopt_array(true);
- assertTrue(2 != %GetOptimizationStatus(deopt_array));
+ assertOptimized(deopt_array);
array = deopt_array(false);
- assertTrue(2 != %GetOptimizationStatus(deopt_array));
+ assertOptimized(deopt_array);
// Check that unexpected changes in the objects stored into the boilerplate
// also force a deopt.
%OptimizeFunctionOnNextCall(deopt_array_literal_all_smis);
array = deopt_array_literal_all_smis(5);
array = deopt_array_literal_all_smis(6);
- assertTrue(2 != %GetOptimizationStatus(deopt_array_literal_all_smis));
+ assertOptimized(deopt_array_literal_all_smis);
assertEquals(0, array[0]);
assertEquals(1, array[1]);
assertEquals(6, array[2]);
array = deopt_array_literal_all_smis(.5);
- assertTrue(1 != %GetOptimizationStatus(deopt_array_literal_all_smis));
+ assertUnoptimized(deopt_array_literal_all_smis);
assertEquals(0, array[0]);
assertEquals(1, array[1]);
assertEquals(.5, array[2]);
%OptimizeFunctionOnNextCall(deopt_array_literal_all_doubles);
array = deopt_array_literal_all_doubles(5);
array = deopt_array_literal_all_doubles(6);
- assertTrue(2 != %GetOptimizationStatus(deopt_array_literal_all_doubles));
+ assertOptimized(deopt_array_literal_all_doubles);
assertEquals(0.5, array[0]);
assertEquals(1, array[1]);
assertEquals(6, array[2]);
var foo = new Object();
array = deopt_array_literal_all_doubles(foo);
- assertTrue(1 != %GetOptimizationStatus(deopt_array_literal_all_doubles));
+ assertUnoptimized(deopt_array_literal_all_doubles);
assertEquals(0.5, array[0]);
assertEquals(1, array[1]);
assertEquals(foo, array[2]);
(function literals_after_osr() {
var color = [0];
// Trigger OSR.
- while (%GetOptimizationStatus(literals_after_osr) == 2) {}
+ while (%GetOptimizationStatus(literals_after_osr, "no sync") == 2) {}
return [color[0]];
})();
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// Flags: --allow-natives-syntax --smi-only-arrays
-// Flags: --noparallel-recompilation
// Flags: --notrack-allocation-sites
// Test element kind of objects.
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// Flags: --allow-natives-syntax --noparallel-recompilation
+// Flags: --allow-natives-syntax
if (%IsParallelRecompilationSupported()) {
print("Parallel recompilation is turned on after all. Skipping this test.");
quit();
}
-function assertUnoptimized(fun) {
- assertTrue(%GetOptimizationStatus(fun) != 1);
-}
-
function f(foo) { return foo.bar(); }
var o = {};
assertEquals(1, f(o));
assertEquals(1, f(o));
+// Mark for parallel optimization.
%OptimizeFunctionOnNextCall(f, "parallel");
-assertEquals(1, f(o)); // Trigger optimization.
-assertUnoptimized(f); // Optimization not yet done.
+// Trigger optimization in the parallel thread.
+assertEquals(1, f(o));
+// While parallel recompilation is running, optimization not yet done.
+assertUnoptimized(f, "no sync");
// Change the prototype chain during optimization to trigger map invalidation.
o.__proto__.__proto__ = { bar: function() { return 2; } };
-%CompleteOptimization(f); // Conclude optimization with...
-assertUnoptimized(f); // ... bailing out due to map dependency.
+// Optimization eventually bails out due to map dependency.
+assertUnoptimized(f, "sync");
assertEquals(2, f(o));
%OptimizeFunctionOnNextCall(f);
f();
// Assert that there has been no deopt.
- assertTrue(%GetOptimizationStatus(f) != 2);
+ assertOptimized(f);
}
test(function add() {
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// Flags: --count-based-interrupts --interrupt-budget=10 --weighted-back-edges
-// Flags: --allow-natives-syntax --noparallel-recompilation
+// Flags: --allow-natives-syntax
// Test that OSR works properly when using count-based interrupting/profiling.
function osr_this() {
var a = 1;
// Trigger OSR.
- while (%GetOptimizationStatus(osr_this) == 2) {}
+ while (%GetOptimizationStatus(osr_this, "no sync") == 2) {}
return a;
}
assertEquals(1, osr_this());
date.getTime();
%OptimizeFunctionOnNextCall(Date.prototype.getTime);
assertThrows(function() { Date.prototype.getTime.call(""); }, TypeError);
-assertTrue(%GetOptimizationStatus(Date.prototype.getTime) != 1);
+assertUnoptimized(Date.prototype.getTime);
date.getYear();
date.getYear();
%OptimizeFunctionOnNextCall(Date.prototype.getYear);
assertThrows(function() { Date.prototype.getYear.call(""); }, TypeError);
-opt_status = %GetOptimizationStatus(Date.prototype.getYear);
-assertTrue(%GetOptimizationStatus(Date.prototype.getTime) != 1);
+assertUnoptimized(Date.prototype.getYear);
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// Flags: --expose-debug-as debug --allow-natives-syntax
-// Flags: --noparallel-recompilation
// This test tests that deoptimization due to debug breaks works for
// inlined functions where the full-code is generated before the
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// Flags: --expose-debug-as debug --expose-gc --noparallel-recompilation
-// Flags: --send-idle-notification
+// Flags: --expose-debug-as debug --expose-gc --send-idle-notification
// Get the Debug object exposed from the debug context global object.
Debug = debug.Debug;
// Flags: --allow-natives-syntax --expose-gc
-/**
- * The possible optimization states of a function. Must be in sync with the
- * return values of Runtime_GetOptimizationStatus() in runtime.cc!
- */
-var OptimizationState = {
- YES: 1,
- NO: 2,
- ALWAYS: 3,
- NEVER: 4
-};
-
function mul (a, b) {
return a * b;
}
%OptimizeFunctionOnNextCall(mul);
mul(0, -1);
-var raw_optimized = %GetOptimizationStatus(mul);
-assertFalse(raw_optimized == OptimizationState.NO);
+assertOptimized(mul);
gc();
-
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// Flags: --allow-natives-syntax --smi-only-arrays --noparallel-recompilation
-// Flags: --notrack-allocation-sites
+// Flags: --allow-natives-syntax --smi-only-arrays --notrack-allocation-sites
// No tracking of allocation sites because it interfers with the semantics
// the test is trying to ensure.
%OptimizeFunctionOnNextCall(testDoubleConversion4);
testDoubleConversion4(new Array(5));
testDoubleConversion4(new Array(5));
- assertTrue(2 != %GetOptimizationStatus(testDoubleConversion4));
+ assertOptimized(testDoubleConversion4);
%ClearFunctionTypeFeedback(testDoubleConversion4);
// Make sure that non-element related map checks that are not preceded by
%OptimizeFunctionOnNextCall(testExactMapHoisting);
testExactMapHoisting(new Array(5));
testExactMapHoisting(new Array(5));
- assertTrue(2 != %GetOptimizationStatus(testExactMapHoisting));
+ assertOptimized(testExactMapHoisting);
%ClearFunctionTypeFeedback(testExactMapHoisting);
// Make sure that non-element related map checks do NOT get hoisted if they
testExactMapHoisting2(new Array(5));
testExactMapHoisting2(new Array(5));
// Temporarily disabled - see bug 2176.
- // assertTrue(2 != %GetOptimizationStatus(testExactMapHoisting2));
+ // assertOptimized(testExactMapHoisting2);
%ClearFunctionTypeFeedback(testExactMapHoisting2);
// Make sure that non-element related map checks do get hoisted if they use
%OptimizeFunctionOnNextCall(testExactMapHoisting3);
testExactMapHoisting3(new Array(5));
testExactMapHoisting3(new Array(5));
- assertTrue(2 != %GetOptimizationStatus(testExactMapHoisting3));
+ assertOptimized(testExactMapHoisting3);
%ClearFunctionTypeFeedback(testExactMapHoisting3);
function testDominatingTransitionHoisting1(a) {
// TODO(verwaest) With current changes the elements transition gets hoisted
// above the access, causing a deopt. We should update the type of access
// rather than forbid hoisting the transition.
- assertTrue(2 != %GetOptimizationStatus(testDominatingTransitionHoisting1));
+ assertOptimized(testDominatingTransitionHoisting1);
%ClearFunctionTypeFeedback(testDominatingTransitionHoisting1);
*/
%OptimizeFunctionOnNextCall(testHoistingWithSideEffect);
testHoistingWithSideEffect(new Array(5));
testHoistingWithSideEffect(new Array(5));
- assertTrue(2 != %GetOptimizationStatus(testHoistingWithSideEffect));
+ assertOptimized(testHoistingWithSideEffect);
%ClearFunctionTypeFeedback(testHoistingWithSideEffect);
function testStraightLineDupeElinination(a,b,c,d,e,f) {
%OptimizeFunctionOnNextCall(testStraightLineDupeElinination);
testStraightLineDupeElinination(new Array(5),0,0,0,0,0);
testStraightLineDupeElinination(new Array(5),0,0,0,0,0);
- assertTrue(2 != %GetOptimizationStatus(testStraightLineDupeElinination));
+ assertOptimized(testStraightLineDupeElinination);
%ClearFunctionTypeFeedback(testStraightLineDupeElinination);
}
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// Flags: --harmony-scoping --allow-natives-syntax --noparallel-recompilation
+// Flags: --harmony-scoping --allow-natives-syntax
// TODO(ES6): properly activate extended mode
"use strict";
}
%OptimizeFunctionOnNextCall(func);
func(12);
- assertTrue(%GetOptimizationStatus(func) != 2);
+ assertOptimized(func);
}
function f1() { }
quit();
}
-function assertUnoptimized(fun) {
- assertTrue(%GetOptimizationStatus(fun) != 1);
-}
-
-function assertOptimized(fun) {
- assertTrue(%GetOptimizationStatus(fun) != 2);
-}
-
function f(x) {
var xx = x * x;
var xxstr = xx.toString();
%OptimizeFunctionOnNextCall(g, "parallel");
f(g(2)); // Trigger optimization.
-assertUnoptimized(f); // Not yet optimized.
-assertUnoptimized(g);
-
-%CompleteOptimization(f); // Wait till optimized code is installed.
-%CompleteOptimization(g);
+assertUnoptimized(f, "no sync"); // Not yet optimized while parallel thread
+assertUnoptimized(g, "no sync"); // is running.
-assertOptimized(f); // Optimized now.
-assertOptimized(g);
+assertOptimized(f, "sync"); // Optimized once we sync with the parallel thread.
+assertOptimized(g, "sync");
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// Flags: --allow-natives-syntax --nouse_inlining --noparallel-recompilation
+// Flags: --allow-natives-syntax --nouse_inlining
// Test for negative zero that doesn't need bail out
test_div_no_deopt_minus_zero();
%OptimizeFunctionOnNextCall(test_div_no_deopt_minus_zero);
test_div_no_deopt_minus_zero();
-assertTrue(2 != %GetOptimizationStatus(test_div_no_deopt_minus_zero));
+assertOptimized(test_div_no_deopt_minus_zero);
// Assert that this code is never executed (i.e., always fails if executed).
var assertUnreachable;
+// Assert that the function code is (not) optimized. If "no sync" is passed
+// as second argument, we do not wait for the parallel optimization thread to
+// finish when polling for optimization status.
+// Only works with --allow-natives-syntax.
+var assertOptimized;
+var assertUnoptimized;
+
+
(function () { // Scope for utility functions.
function classOf(object) {
throw new MjsUnitAssertionError(message);
};
+
+ var OptimizationStatus;
+ try {
+ OptimizationStatus =
+ new Function("fun", "sync", "return %GetOptimizationStatus(fun, sync);");
+ } catch (e) {
+ OptimizationStatus = function() {
+ throw new Error("natives syntax not allowed");
+ }
+ }
+
+ assertUnoptimized = function assertUnoptimized(fun, sync_opt, name_opt) {
+ if (sync_opt === undefined) sync_opt = "";
+ assertTrue(OptimizationStatus(fun, sync_opt) != 1, name_opt);
+ }
+
+ assertOptimized = function assertOptimized(fun, sync_opt, name_opt) {
+ if (sync_opt === undefined) sync_opt = "";
+ assertTrue(OptimizationStatus(fun, sync_opt) != 2, name_opt);
+ }
+
})();
o1();
// Check that the given function was optimized.
- var o1_status = %GetOptimizationStatus(o1);
- assertTrue(o1_status == 1 // optimized
- || o1_status == 3 // optimized (always opt)
- || o1_status == 5); // lazy recompile requested
+ assertOptimized(o1);
// Test the %NeverOptimizeFunction runtime call.
%NeverOptimizeFunction(u1);
u2(); u2();
// 2 => not optimized.
- assertTrue(%GetOptimizationStatus(u1) == 2);
- assertFalse(%GetOptimizationStatus(u2) == 2);
+ assertUnoptimized(u1);
+ assertOptimized(u2);
}
\ No newline at end of file
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// Flags: --allow-natives-syntax
-// Flags: --parallel-recompilation --parallel-recompilation-delay=50
+// Flags: --parallel-recompilation --parallel-recompilation-delay=100
if (!%IsParallelRecompilationSupported()) {
print("Parallel recompilation is disabled. Skipping this test.");
quit();
}
-function assertUnoptimized(fun) {
- assertTrue(%GetOptimizationStatus(fun) != 1);
-}
-
function f1(a, i) {
return a[i] + 0.5;
}
// Optimized code of f1 depends on initial object and array maps.
%OptimizeFunctionOnNextCall(f1, "parallel");
+// Trigger optimization in the background thread
assertEquals(0.5, f1(arr, 0));
-assertUnoptimized(f1); // Not yet optimized.
Object.prototype[1] = 1.5; // Invalidate current initial object map.
assertEquals(2, f1(arr, 1));
-%CompleteOptimization(f1); // Conclude optimization with...
-assertUnoptimized(f1); // ... bailing out due to map dependency.
+// Not yet optimized while background thread is running.
+assertUnoptimized(f1, "no sync");
+// Sync with background thread to conclude optimization, which bails out
+// due to map dependency.
+assertUnoptimized(f1, "sync");
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// Flags: --track-fields --track-double-fields --allow-natives-syntax
-// Flags: --parallel-recompilation --parallel-recompilation-delay=50
+// Flags: --parallel-recompilation --parallel-recompilation-delay=100
if (!%IsParallelRecompilationSupported()) {
print("Parallel recompilation is disabled. Skipping this test.");
quit();
}
-function assertUnoptimized(fun) {
- assertTrue(%GetOptimizationStatus(fun) != 1);
-}
-
function new_object() {
var o = {};
o.a = 1;
%OptimizeFunctionOnNextCall(add_field, "parallel");
var o = new_object();
-add_field(o); // Trigger optimization.
-assertUnoptimized(add_field); // Not yet optimized.
-o.c = 2.2; // Invalidate transition map.
-%CompleteOptimization(add_field); // Conclude optimization with...
-assertUnoptimized(add_field); // ... bailing out due to map dependency.
-
+// Trigger optimization in the background thread.
+add_field(o);
+// Invalidate transition map while optimization is underway.
+o.c = 2.2;
+// Sync with background thread to conclude optimization that bailed out.
+assertUnoptimized(add_field, "sync");
%OptimizeFunctionOnNextCall(g, "parallel");
f(0); // g() is disabled for optimization on inlining attempt.
// Attempt to optimize g() should not run into any assertion.
-%CompleteOptimization(g);
+assertUnoptimized(g, "sync");
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// Flags: --allow-natives-syntax --noparallel-recompilation
+// Flags: --allow-natives-syntax
// An exception thrown in a function optimized by on-stack replacement (OSR)
// should be able to construct a receiver from all optimized stack frames.
g();
} else {
// Run for a bit as long as h is unoptimized.
- while (%GetOptimizationStatus(h) == 2) {
+ while (%GetOptimizationStatus(h, "no sync") == 2) {
for (var j = 0; j < 100; j++) g();
}
g();
mul(0, 0);
%OptimizeFunctionOnNextCall(mul);
assertEquals(0, mul(0, -1));
-assertTrue(%GetOptimizationStatus(mul) != 2);
+assertOptimized(mul);
function div(x, y) {
return (x / y) | 0;
div(4, 2);
%OptimizeFunctionOnNextCall(div);
assertEquals(1, div(5, 3));
-assertTrue(%GetOptimizationStatus(div) != 2);
+assertOptimized(div);
// Second compilation should have noticed that LICM wasn't a good idea, and now
// function should no longer deopt when called.
test();
-assertTrue(2 != %GetOptimizationStatus(test));
+assertOptimized(test);
%OptimizeFunctionOnNextCall(foo);
foo();
-// Function should be optimized now.
-assertTrue(%GetOptimizationStatus(foo) != 2);
+assertOptimized(foo);
// Flags: --allow-natives-syntax --expose-gc
-/**
- * The possible optimization states of a function. Must be in sync with the
- * return values of Runtime_GetOptimizationStatus() in runtime.cc!
- */
-
-var OptimizationState = {
- YES: 1,
- NO: 2,
- ALWAYS: 3,
- NEVER: 4
-};
-
function simple() {
return simple_two_args(0, undefined);
}
simple();
%OptimizeFunctionOnNextCall(simple);
simple();
-var raw_optimized = %GetOptimizationStatus(simple);
-assertFalse(raw_optimized == OptimizationState.NO);
+assertOptimized(simple);
gc();
-
f();
%OptimizeFunctionOnNextCall(f);
f();
-assertTrue(%GetOptimizationStatus(f) != 2);
-
+assertOptimized(f);
callConstantFunctionOnPrototype(receiver);
// Make sure that the function is still optimized.
-assertTrue(2 != %GetOptimizationStatus(callConstantFunctionOnPrototype));
+assertOptimized(callConstantFunctionOnPrototype);
}
f();
-assertTrue(%GetOptimizationStatus(f) != 2);
+assertOptimized(f);
function g() {
}
g();
-assertTrue(%GetOptimizationStatus(g) != 2);
-
+assertOptimized(g);
function outer() {
inner(1,2,3);
// Trigger OSR.
- while (%GetOptimizationStatus(outer) == 2) {}
+ while (%GetOptimizationStatus(outer, "no sync") == 2) {}
}
outer();
quit();
}
-function assertUnoptimized(fun) {
- assertTrue(%GetOptimizationStatus(fun) != 1);
-}
-
function test(fun) {
fun();
fun();
+ // Mark for parallel optimization.
%OptimizeFunctionOnNextCall(fun, "parallel");
- fun(); // Trigger optimization in the background.
- gc(); // Tenure cons string.
- assertUnoptimized(fun); // Compilation not complete yet.
- %CompleteOptimization(fun); // Compilation embeds tenured cons string.
- gc(); // Visit embedded cons string during mark compact.
+ //Trigger optimization in the background.
+ fun();
+ //Tenure cons string.
+ gc();
+ // In the mean time, parallel recompiling is not complete yet.
+ assertUnoptimized(fun, "no sync");
+ // Parallel recompilation eventually finishes and embeds tenured cons string.
+ assertOptimized(fun, "sync");
+ //Visit embedded cons string during mark compact.
+ gc();
}
function f() {
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// Flags: --expose-debug-as debug --allow-natives-syntax
-// Flags: --parallel-recompilation --parallel-recompilation-delay=300
+// Flags: --parallel-recompilation --parallel-recompilation-delay=100
if (!%IsParallelRecompilationSupported()) {
print("Parallel recompilation is disabled. Skipping this test.");
Debug.setListener(listener); // Activate debugger.
Debug.setBreakPoint(f, 2, 0); // Force deopt.
-%CompleteOptimization(f); // Install optimized code.
+// Sync with parallel optimization thread. But no optimized code is installed.
+assertUnoptimized(f, "sync");
f(); // Trigger break point.
assertEquals(1, listened);
// Test dictionary -> double elements -> dictionary elements round trip
// Flags: --allow-natives-syntax --unbox-double-arrays --expose-gc
-// Flags: --noparallel-recompilation
var large_array_size = 100000;
var approx_dict_to_elements_threshold = 70000;
-Infinity,
expected_array_value(7));
- assertTrue(%GetOptimizationStatus(test_various_stores) != 2);
+ assertOptimized(test_various_stores);
// Make sure that we haven't converted from fast double.
assertTrue(%HasFastDoubleElements(large_array));
projects / platform / upstream / v8.git / commitdiff