diff options
Diffstat (limited to 'tests/benchmarks/qml/deltablue')
| -rw-r--r-- | tests/benchmarks/qml/deltablue/BaseConstraint.qml | 11 | ||||
| -rw-r--r-- | tests/benchmarks/qml/deltablue/CMakeLists.txt | 37 | ||||
| -rw-r--r-- | tests/benchmarks/qml/deltablue/ChainTest.qml | 67 | ||||
| -rw-r--r-- | tests/benchmarks/qml/deltablue/Constraint.qml | 147 | ||||
| -rw-r--r-- | tests/benchmarks/qml/deltablue/Main.qml | 132 | ||||
| -rw-r--r-- | tests/benchmarks/qml/deltablue/Main2.qml | 16 | ||||
| -rw-r--r-- | tests/benchmarks/qml/deltablue/Plan.qml | 27 | ||||
| -rw-r--r-- | tests/benchmarks/qml/deltablue/Planner.qml | 194 | ||||
| -rw-r--r-- | tests/benchmarks/qml/deltablue/ProjectionTest.qml | 112 | ||||
| -rw-r--r-- | tests/benchmarks/qml/deltablue/Satisfaction.qml | 13 | ||||
| -rw-r--r-- | tests/benchmarks/qml/deltablue/Strength.qml | 45 | ||||
| -rw-r--r-- | tests/benchmarks/qml/deltablue/Variable.qml | 48 | ||||
| -rw-r--r-- | tests/benchmarks/qml/deltablue/deltablue.js | 858 | ||||
| -rw-r--r-- | tests/benchmarks/qml/deltablue/main.cpp | 68 |
14 files changed, 1775 insertions, 0 deletions
diff --git a/tests/benchmarks/qml/deltablue/BaseConstraint.qml b/tests/benchmarks/qml/deltablue/BaseConstraint.qml new file mode 100644 index 0000000000..4de049699e --- /dev/null +++ b/tests/benchmarks/qml/deltablue/BaseConstraint.qml @@ -0,0 +1,11 @@ +// Copyright (C) 2023 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only + +pragma Strict +import QtQml + +QtObject { + required property int strength + property int satisfaction: Satisfaction.NONE + property bool isInput: false +} diff --git a/tests/benchmarks/qml/deltablue/CMakeLists.txt b/tests/benchmarks/qml/deltablue/CMakeLists.txt new file mode 100644 index 0000000000..36a682315a --- /dev/null +++ b/tests/benchmarks/qml/deltablue/CMakeLists.txt @@ -0,0 +1,37 @@ +# Copyright (C) 2023 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +qt_internal_add_benchmark(tst_deltablue + SOURCES + main.cpp + LIBRARIES + Qt::Qml + Qt::Test +) + + +set_source_files_properties( + Main.qml + Strength.qml + PROPERTIES + QT_QML_SINGLETON_TYPE True +) + +qt_add_qml_module(tst_deltablue + URI DeltaBlue + VERSION 1.0 + QML_FILES + BaseConstraint.qml + ChainTest.qml + Constraint.qml + Main.qml + Main2.qml + Plan.qml + Planner.qml + ProjectionTest.qml + Satisfaction.qml + Strength.qml + Variable.qml + deltablue.js +) + diff --git a/tests/benchmarks/qml/deltablue/ChainTest.qml b/tests/benchmarks/qml/deltablue/ChainTest.qml new file mode 100644 index 0000000000..f671af6567 --- /dev/null +++ b/tests/benchmarks/qml/deltablue/ChainTest.qml @@ -0,0 +1,67 @@ +// Copyright (C) 2023 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only + +pragma ComponentBehavior: Bound +pragma Strict +import QtQml + +QtObject { + id: chainTest + property int length: 100 + + property Planner planner: Planner { id: planner } + property Plan plan: Plan { id: plan } + + property Component variable: Variable {} + property list<Variable> variables: new Array(length) + property Variable first: variables[0] + property Variable last: variables[length - 1] + function setVariable(i: int, v: Variable) { variables[i] = v; } + + property Component constraint: Constraint {} + + property Constraint stayConstraint: Constraint { + id: stayConstraint + myOutput: chainTest.last + strength: Strength.STRONG_DEFAULT + } + + property Constraint editConstraint: Constraint { + id: editConstraint + isInput: true + myOutput: chainTest.first + strength: Strength.PREFERRED + } + + Component.onCompleted: { + for (let i = 0, end = length; i < end; ++i) + setVariable(i, variable.createObject(this, {objectName: "v" + i}) as Variable); + + let v = variables; + let p = planner; + for (let i = 0, end = length - 1; i < end; ++i) { + p.incrementalAdd(constraint.createObject(this, { + myInput: v[i], + myOutput: v[i + 1], + strength: Strength.REQUIRED + }) as Constraint); + } + + planner.incrementalAdd(stayConstraint) + planner.incrementalAdd(editConstraint) + } + + function verify(i: int) { + if (last.value !== i) + console.error("Chain test failed.", last.value, i, first.value); + } + + function run() { + planner.populatePlanFromConstraint(editConstraint, plan); + for (let i = 0; i < 100; ++i) { + first.value = i; + plan.execute(); + verify(i); + } + } +} diff --git a/tests/benchmarks/qml/deltablue/Constraint.qml b/tests/benchmarks/qml/deltablue/Constraint.qml new file mode 100644 index 0000000000..bf84870fa9 --- /dev/null +++ b/tests/benchmarks/qml/deltablue/Constraint.qml @@ -0,0 +1,147 @@ +// Copyright (C) 2023 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only + +pragma Strict +import QtQml + +BaseConstraint { + id: self + + property Variable myInput + property Variable myOutput + + property Variable scale + property Variable offset + + function addToGraph() { + let ihn = myInput; + if (ihn) + ihn.addConstraint(self); + let out = myOutput; + if (out) + out.addConstraint(self); + let s = scale; + if (s) + s.addConstraint(self); + let o = offset; + if (o) + o.addConstraint(self); + satisfaction = Satisfaction.NONE; + } + + function removeFromGraph() { + if (myInput) + myInput.removeConstraint(self); + if (myOutput) + myOutput.removeConstraint(self); + if (scale) + scale.removeConstraint(self); + if (offset) + offset.removeConstraint(self); + satisfaction = Satisfaction.NONE; + } + + property Variable input: (satisfaction === Satisfaction.BACKWARD) + ? myOutput + : myInput + + property Variable output: (satisfaction === Satisfaction.BACKWARD) + ? myInput + : myOutput + + function recalculate() { + let ihn = input; + let out = output; + + if (!ihn) { + out.walkStrength = strength; + out.stay = !isInput; + return; + } + + out.walkStrength = Strength.weakestOf(strength, ihn.walkStrength); + let stay = ihn.stay; + + // Optimize for number of lookups. We lookup scale and offset only once and we keep + // stay in a local as long as we can. + + let s = scale + if (s) + stay = stay && s.stay; + + let o = offset + if (o) + stay = stay && o.stay; + + out.stay = stay; + + if (stay) + out.value = evaluate(); + } + + function chooseMethod(mark: int) { + let ihn = myInput; + let out = myOutput; + let outStrength = out.walkStrength; + + if (!ihn) { + satisfaction = (out.mark !== mark && Strength.stronger(strength, outStrength)) + ? Satisfaction.FORWARD + : Satisfaction.NONE; + return; + } + + let ihnStrength = ihn.walkStrength; + + if (Strength.weaker(ihnStrength, outStrength)) { + satisfaction = Strength.stronger(strength, ihnStrength) + ? Satisfaction.BACKWARD + : Satisfaction.NONE; + return; + } + + satisfaction = Strength.stronger(strength, outStrength) + ? Satisfaction.FORWARD + : Satisfaction.BACKWARD + } + + function markInputs(mark: int) { + let i = input; + if (i) + i.mark = mark; + let s = scale; + if (s) + s.mark = mark; + let o = offset; + if (o) + o.mark = mark; + } + + function inputsKnown(mark: int) : bool { + let ihn = input; + return !ihn || ihn.mark === mark || ihn.stay || ihn.determinedBy === null; + } + + function evaluate() : int { + let result = input.value; + + // This is a rather hot code path. It pays off to do the lookups for offset and scale + // only once + let o = offset; + let s = scale; + + if (satisfaction === Satisfaction.BACKWARD) { + if (o) + result = result - o.value; + if (s) + result = result / s.value; + } else { + if (s) + result = result * s.value; + if (o) + result = result + o.value; // TODO: += and -= miscompile! + } + + return result; + } +} diff --git a/tests/benchmarks/qml/deltablue/Main.qml b/tests/benchmarks/qml/deltablue/Main.qml new file mode 100644 index 0000000000..9260cace31 --- /dev/null +++ b/tests/benchmarks/qml/deltablue/Main.qml @@ -0,0 +1,132 @@ +// Copyright (C) 2023 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only + +pragma Singleton +import QtQml + +QtObject { + property Component newPlanner: Planner {} + property Component newVariable: Variable {} + property Component newConstraint: Constraint { + id: constraint + Component.onCompleted: planner.incrementalAdd(constraint) + } + property Component newPlan: Plan {} + + // Global variable holding the current planner. + property Planner planner: null + + property Variable prev + property Variable first + property Variable last + function chainTest(n: int) { + planner = newPlanner.createObject(this) as Planner; + prev = null; + first = null; + last = null; + + // Build chain of n equality constraints + for (var i = 0; i <= n; i++) { + var v = newVariable.createObject(this, {objectName: "v" + i}) as Variable; + if (prev !== null) { + newConstraint.createObject(this, { + myInput: prev, + myOutput: v, + strength: Strength.REQUIRED + }); + } + if (i === 0) + first = v; + if (i === n) + last = v; + prev = v; + } + + newConstraint.createObject(this, {myOutput: last, strength: Strength.STRONG_DEFAULT}); + let chainConstraint = + newConstraint.createObject(this, { + isInput: true, + myOutput: first, + strength: Strength.PREFERRED + }) as Constraint; + + let plan = newPlan.createObject(this); + planner.populatePlanFromConstraint(chainConstraint, plan); + for (let i = 0; i < 100; i++) { + first.value = i; + plan.execute(); + if (last.value != i) + console.error("Chain test failed."); + } + } + + property Variable scale + property Variable offset + property Variable src + property Variable dst + property list<Variable> dests + function projectionTest(n: int) { + planner = newPlanner.createObject(this) as Planner; + scale = newVariable.createObject(this, {objectName: "scale", value: 10}) as Variable; + offset = newVariable.createObject(this, {objectName: "offset", value: 1000}) as Variable; + src = null; + dst = null; + + dests = []; + for (let i = 0; i < n; i++) { + src = newVariable.createObject(this, {objectName: "src" + i, value: i}) as Variable; + dst = newVariable.createObject(this, {objectName: "dst" + i, value: i}) as Variable; + dests.push(dst); + newConstraint.createObject(this, {myOutput: src, strength: Strength.NORMAL}); + newConstraint.createObject(this, { + myInput: src, + myOutput: dst, + scale: scale, + offset: offset, + strength: Strength.REQUIRED + }); + } + + change(src, 17); + if (dst.value !== 1170) + console.error("Projection 1 failed"); + change(dst, 1050); + if (src.value !== 5) + console.error("Projection 2 failed"); + change(scale, 5); + for (let i = 0; i < n - 1; i++) { + if (dests[i].value !== i * 5 + 1000) + console.error("Projection 3 failed"); + } + change(offset, 2000); + for (let i = 0; i < n - 1; i++) { + if (dests[i].value !== i * 5 + 2000) + console.error("Projection 4 failed"); + } + } + + property Constraint edit + function change(v: Variable, newValue: int) { + edit = newConstraint.createObject(this, { + isInput: true, + myOutput: v, + strength: Strength.PREFERRED + }) as Constraint + let plan = newPlan.createObject(this); + planner.populatePlanFromConstraint(edit, plan); + for (let i = 0; i < 10; i++) { + v.value = newValue; + plan.execute(); + } + + if (edit.satisfaction !== Satisfaction.NONE) + planner.incrementalRemove(edit); + else + edit.removeFromGraph(); + } + + function deltaBlue() { + chainTest(100); + projectionTest(100); + } +} diff --git a/tests/benchmarks/qml/deltablue/Main2.qml b/tests/benchmarks/qml/deltablue/Main2.qml new file mode 100644 index 0000000000..5f2f610fb6 --- /dev/null +++ b/tests/benchmarks/qml/deltablue/Main2.qml @@ -0,0 +1,16 @@ +// Copyright (C) 2023 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only + +import QtQml + +import "deltablue.js" as DeltaBlue + +QtObject { + property var chain: DeltaBlue.chainTest(100) + property var projection: DeltaBlue.projectionTest(100); + + function deltaBlue() { + chain(); + projection(); + } +} diff --git a/tests/benchmarks/qml/deltablue/Plan.qml b/tests/benchmarks/qml/deltablue/Plan.qml new file mode 100644 index 0000000000..4e3bd7c8a6 --- /dev/null +++ b/tests/benchmarks/qml/deltablue/Plan.qml @@ -0,0 +1,27 @@ +// Copyright (C) 2023 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only + +pragma Strict +import QtQml + +QtObject { + property list<Constraint> v + + function clear() { + v.length = 0; + } + + function addConstraint(c: Constraint) { + let constraints = v; + constraints[constraints.length++] = c; + } + + function execute() { + let constraints = v; + for (let i = 0, length = constraints.length; i < length; ++i) { + let c = constraints[i]; + if (c.input) + c.output.value = c.evaluate(); + } + } +} diff --git a/tests/benchmarks/qml/deltablue/Planner.qml b/tests/benchmarks/qml/deltablue/Planner.qml new file mode 100644 index 0000000000..8642b9e62f --- /dev/null +++ b/tests/benchmarks/qml/deltablue/Planner.qml @@ -0,0 +1,194 @@ +// Copyright (C) 2023 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only + +pragma Strict +pragma ComponentBehavior: Bound + +import QtQml + +QtObject { + id: planner + + component Remover: QtObject { + property list<Constraint> unsatisfied + property list<Variable> toRemove + + function removeOne(v: Variable) { + let vDeterminedBy = v.determinedBy; + for (let i = 0, length = v.length(); i < length; ++i) { + let next = v.constraint(i) as Constraint; + if (next.satisfaction === Satisfaction.NONE) { + let u = unsatisfied; + u[u.length++] = next; + } else if (next !== vDeterminedBy) { + next.recalculate(); + let t = toRemove; + t[t.length++] = next.output; + } + } + } + + function run(c: Constraint) { + c.satisfaction = Satisfaction.NONE; + c.removeFromGraph(); + + let out = c.output as Variable; + out.determinedBy = null; + out.walkStrength = Strength.WEAKEST; + out.stay = true; + + removeOne(out); + let t = toRemove; + while (t.length > 0) { + let one = t[t.length - 1]; + --t.length; + removeOne(one); + } + + let u = unsatisfied; + let ss = Strength; + let sat = satisfier + for (let s = ss.REQUIRED, end = ss.WEAKEST; s !== end; s = ss.nextWeaker(s)) { + for (let i = 0, length = u.length; i < length; ++i) { + let uu = u[i]; + if (uu.strength === s) + sat.run(uu); + } + } + + u.length = 0; + } + } + + component Satisfier: QtObject { + property list<Constraint> todo + + function addPropagate(c: Constraint, mark: int) : bool { + let d = c; + while (true) { + let output = d.output as Variable; + + if (output.mark === mark) { + remover.run(c); + todo.length = 0; + return false; + } + d.recalculate(); + + let outputDeterminedBy = output.determinedBy; + for (let i = 0, length = output.length(); i < length; ++i) { + let dd = output.constraint(i) as Constraint; + if (dd !== outputDeterminedBy && dd.satisfaction !== Satisfaction.NONE) + todo[todo.length++] = dd; + } + + let todoLength = todo.length; + if (todoLength === 0) + break; + + d = todo[todoLength - 1] as Constraint; + --todo.length; + } + return true; + } + + function satisfy(c: Constraint, mark: int) : Constraint { + c.chooseMethod(mark); + if (c.satisfaction === Satisfaction.NONE) { + if (c.strength === Strength.REQUIRED) + console.error("Could not satisfy a required constraint!"); + return null; + } + + c.markInputs(mark); + let out = c.output as Variable; + let overridden = out.determinedBy as Constraint; + if (overridden !== null) + overridden.satisfaction = Satisfaction.NONE; + + out.determinedBy = c; + if (!addPropagate(c, mark)) + console.error("Cycle encountered"); + + out.mark = mark; + return overridden; + } + + function run(c: Constraint) { + let mark = planner.newMark(); + let overridden = satisfy(c, mark); + while (overridden !== null) + overridden = satisfy(overridden, mark); + } + } + + component Populator: QtObject { + property list<Constraint> constraints + + function run(initial: Constraint, plan: Plan) { + // TODO: If we pass initial as a list here, we cannot assign to constraints! + let l = constraints; + l.length = 1; + l[0] = initial; + plan.clear(); + for (let i = 0; i < l.length; ++i) { + let c = l[i]; + if (!c.isInput || c.satisfaction === Satisfaction.NONE) { + // Not eligible for inclusion. Remove + let last = l[l.length - 1]; + if (i < l.length--) + l[i] = last; + } + } + + let mark = planner.newMark(); + while (l.length > 0) { + let c = l[l.length - 1]; + --l.length; + + let output = c.output as Variable; + if (output.mark !== mark && c.inputsKnown(mark)) { + plan.addConstraint(c); + output.mark = mark; + addConstraintsConsumingTo(output); + } + } + } + + function addConstraintsConsumingTo(v: Variable) { + let vDeterminedBy = v.determinedBy; + let l = constraints; + for (let i = 0, length = v.length(); i < length; ++i) { + let c = v.constraint(i) as Constraint; + if (c !== vDeterminedBy && c.satisfaction !== Satisfaction.NONE) + l[l.length++] = c; + } + } + } + + property Remover remover: Remover { id: remover } + property Satisfier satisfier: Satisfier { id: satisfier } + property Populator populator: Populator { id: populator } + + property int currentMark: 0 + + + function incrementalAdd(c : Constraint) { + c.addToGraph(); + satisfier.run(c); + } + + function incrementalRemove(c : Constraint) { + remover.run(c); + } + + // TODO: If we pass a list here and modify it in place, the behavior differs between + // interpreter and compiler. + function populatePlanFromConstraint(c: Constraint, plan: Plan) { + populator.run(c, plan) + } + + function newMark() : int { + return ++currentMark; + } +} diff --git a/tests/benchmarks/qml/deltablue/ProjectionTest.qml b/tests/benchmarks/qml/deltablue/ProjectionTest.qml new file mode 100644 index 0000000000..4386e226f6 --- /dev/null +++ b/tests/benchmarks/qml/deltablue/ProjectionTest.qml @@ -0,0 +1,112 @@ +// Copyright (C) 2023 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only + +pragma ComponentBehavior: Bound +pragma Strict +import QtQml + +QtObject { + id: projectionTest + property int length: 100 + + property Planner planner: Planner { + id: planner + } + + property Variable scale: Variable { + id: scaleVariable + objectName: "scale" + value: 10 + } + + property Variable offset: Variable { + id: offsetVariable + objectName: "offset" + value: 1000 + } + + property Component variable: Variable {} + + property list<Variable> sources: new Array(length) + property Variable src: sources[length - 1] + function setSource(i: int, v: Variable) { sources[i] = v; } + + property list<Variable> destinations: new Array(length) + property Variable dst: destinations[length - 1] + function setDestination(i: int, v: Variable) { destinations[i] = v; } + + property Component constraint: Constraint {} + + Component.onCompleted: { + let p = planner; + for (let i = 0, end = length; i < end; ++i) { + let source = variable.createObject(this, { + objectName: "src" + i, + value: i + }) as Variable; + setSource(i, source); + + let destination = variable.createObject(this, { + objectName: "dst" + i, + value: i + }) as Variable; + setDestination(i, destination); + + p.incrementalAdd(constraint.createObject(this, { + myOutput: source, + strength: Strength.NORMAL + }) as Constraint); + + p.incrementalAdd(constraint.createObject(this, { + myInput: source, + myOutput: destination, + scale: scaleVariable, + offset: offsetVariable, + strength: Strength.REQUIRED + }) as Constraint); + } + } + + component Changer : Constraint { + id: editConstraint + isInput: true + + strength: Strength.PREFERRED + + property Plan plan: Plan {} + + function run(v: Variable, newValue: int) { + myOutput = v; + planner.incrementalAdd(editConstraint); + planner.populatePlanFromConstraint(editConstraint, plan); + for (let i = 0; i < 10; ++i) { + v.value = newValue; + plan.execute(); + } + planner.incrementalRemove(editConstraint); + } + } + + property Changer changer: Changer { id: changer } + + function run() { + changer.run(src, 17); + if (dst.value !== 1170) + console.error("Projection 1 failed", dst.value, offsetVariable.value); + changer.run(dst, 1050); + if (src.value !== 5) + console.error("Projection 2 failed", src.value, offsetVariable.value); + changer.run(scaleVariable, 5); + + let d = destinations; + for (let i = 0, end = length - 1; i < end; ++i) { + if (d[i].value !== i * 5 + 1000) + console.error("Projection 3 failed"); + } + changer.run(offsetVariable, 2000); + for (let i = 0, end = length - 1; i < end; ++i) { + if (d[i].value !== i * 5 + 2000) + console.error("Projection 4 failed"); + } + } +} diff --git a/tests/benchmarks/qml/deltablue/Satisfaction.qml b/tests/benchmarks/qml/deltablue/Satisfaction.qml new file mode 100644 index 0000000000..a281f41c62 --- /dev/null +++ b/tests/benchmarks/qml/deltablue/Satisfaction.qml @@ -0,0 +1,13 @@ +// Copyright (C) 2023 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only + +pragma Strict +import QtQml + +QtObject { + enum Value { + NONE = 0, + FORWARD = 1, + BACKWARD = 2 + } +} diff --git a/tests/benchmarks/qml/deltablue/Strength.qml b/tests/benchmarks/qml/deltablue/Strength.qml new file mode 100644 index 0000000000..529230ca80 --- /dev/null +++ b/tests/benchmarks/qml/deltablue/Strength.qml @@ -0,0 +1,45 @@ +// Copyright (C) 2023 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only + +pragma Strict +pragma Singleton +import QtQml + +QtObject { + enum Value { + REQUIRED = 0, + STRONG_PREFERRED = 1, + PREFERRED = 2, + STRONG_DEFAULT = 3, + NORMAL = 4, + WEAK_DEFAULT = 5, + WEAKEST = 6 + } + + function stronger(s1: int, s2: int) : bool { + return s1 < s2; + } + + function weaker(s1: int, s2: int) : bool { + return s1 > s2; + } + + function weakestOf(s1: int, s2: int) : int { + return weaker(s1, s2) ? s1 : s2; + } + + function strongestOf(s1: int, s2: int) : int { + return stronger(s1, s2) ? s1 : s2; + } + + function nextWeaker(s: int) : int { + switch (s) { + case 0: return Strength.WEAKEST; + case 1: return Strength.WEAK_DEFAULT; + case 2: return Strength.NORMAL; + case 3: return Strength.STRONG_DEFAULT; + case 4: return Strength.PREFERRED; + case 5: return Strength.REQUIRED; + } + } +} diff --git a/tests/benchmarks/qml/deltablue/Variable.qml b/tests/benchmarks/qml/deltablue/Variable.qml new file mode 100644 index 0000000000..6b3411e520 --- /dev/null +++ b/tests/benchmarks/qml/deltablue/Variable.qml @@ -0,0 +1,48 @@ +// Copyright (C) 2023 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only + +pragma Strict +import QtQml + +QtObject { + property int value: 0 + property list<BaseConstraint> constraints + property BaseConstraint determinedBy: null + property int mark: 0 + property int walkStrength: Strength.WEAKEST + property bool stay: true + + function addConstraint(c: BaseConstraint) { + let l = constraints; + l[l.length++] = c; + } + + function removeConstraint(c: BaseConstraint) { + let l = constraints; + let index = 0; + let skipped = 0; + for (let i = 0, length = l.length; i < length; ++i) { + let value = l[i] as BaseConstraint; + if (value !== c) { + if (index != i) + l[index] = value; + ++index + } else { + ++skipped; + } + } + + l.length -= skipped; + + if (determinedBy === c) + determinedBy = null; + } + + function length(): int { + return constraints.length + } + + function constraint(i: int) : BaseConstraint { + return constraints[i]; + } +} diff --git a/tests/benchmarks/qml/deltablue/deltablue.js b/tests/benchmarks/qml/deltablue/deltablue.js new file mode 100644 index 0000000000..b57af3f6f2 --- /dev/null +++ b/tests/benchmarks/qml/deltablue/deltablue.js @@ -0,0 +1,858 @@ +// Copyright (C) 2023 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only + +/** + * A JavaScript implementation of the DeltaBlue constraint-solving + * algorithm, as described in: + * + * "The DeltaBlue Algorithm: An Incremental Constraint Hierarchy Solver" + * Bjorn N. Freeman-Benson and John Maloney + * January 1990 Communications of the ACM, + * also available as University of Washington TR 89-08-06. + * + * Beware: this benchmark is written in a grotesque style where + * the constraint model is built by side-effects from constructors. + * I've kept it this way to avoid deviating too much from the original + * implementation. + */ + + +/* --- O b j e c t M o d e l --- */ + +Object.prototype.inheritsFrom = function (shuper) { + function Inheriter() { } + Inheriter.prototype = shuper.prototype; + this.prototype = new Inheriter(); + this.superConstructor = shuper; +} + +function OrderedCollection() { + this.elms = new Array(); +} + +OrderedCollection.prototype.add = function (elm) { + this.elms.push(elm); +} + +OrderedCollection.prototype.at = function (index) { + return this.elms[index]; +} + +OrderedCollection.prototype.size = function () { + return this.elms.length; +} + +OrderedCollection.prototype.removeFirst = function () { + return this.elms.pop(); +} + +OrderedCollection.prototype.remove = function (elm) { + var index = 0, skipped = 0; + for (var i = 0; i < this.elms.length; i++) { + var value = this.elms[i]; + if (value != elm) { + this.elms[index] = value; + index++; + } else { + skipped++; + } + } + for (var i = 0; i < skipped; i++) + this.elms.pop(); +} + +/* --- * + * S t r e n g t h + * --- */ + +/** + * Strengths are used to measure the relative importance of constraints. + * New strengths may be inserted in the strength hierarchy without + * disrupting current constraints. Strengths cannot be created outside + * this class, so pointer comparison can be used for value comparison. + */ +function Strength(strengthValue, name) { + this.strengthValue = strengthValue; + this.name = name; +} + +Strength.stronger = function (s1, s2) { + return s1.strengthValue < s2.strengthValue; +} + +Strength.weaker = function (s1, s2) { + return s1.strengthValue > s2.strengthValue; +} + +Strength.weakestOf = function (s1, s2) { + return this.weaker(s1, s2) ? s1 : s2; +} + +Strength.strongest = function (s1, s2) { + return this.stronger(s1, s2) ? s1 : s2; +} + +Strength.prototype.nextWeaker = function () { + switch (this.strengthValue) { + case 0: return Strength.WEAKEST; + case 1: return Strength.WEAK_DEFAULT; + case 2: return Strength.NORMAL; + case 3: return Strength.STRONG_DEFAULT; + case 4: return Strength.PREFERRED; + case 5: return Strength.REQUIRED; + } +} + +// Strength constants. +Strength.REQUIRED = new Strength(0, "required"); +Strength.STONG_PREFERRED = new Strength(1, "strongPreferred"); +Strength.PREFERRED = new Strength(2, "preferred"); +Strength.STRONG_DEFAULT = new Strength(3, "strongDefault"); +Strength.NORMAL = new Strength(4, "normal"); +Strength.WEAK_DEFAULT = new Strength(5, "weakDefault"); +Strength.WEAKEST = new Strength(6, "weakest"); + +/* --- * + * C o n s t r a i n t + * --- */ + +/** + * An abstract class representing a system-maintainable relationship + * (or "constraint") between a set of variables. A constraint supplies + * a strength instance variable; concrete subclasses provide a means + * of storing the constrained variables and other information required + * to represent a constraint. + */ +function Constraint(strength) { + this.strength = strength; +} + +/** + * Activate this constraint and attempt to satisfy it. + */ +Constraint.prototype.addConstraint = function () { + this.addToGraph(); + planner.incrementalAdd(this); +} + +/** + * Attempt to find a way to enforce this constraint. If successful, + * record the solution, perhaps modifying the current dataflow + * graph. Answer the constraint that this constraint overrides, if + * there is one, or nil, if there isn't. + * Assume: I am not already satisfied. + */ +Constraint.prototype.satisfy = function (mark) { + this.chooseMethod(mark); + if (!this.isSatisfied()) { + if (this.strength == Strength.REQUIRED) + alert("Could not satisfy a required constraint!"); + return null; + } + this.markInputs(mark); + var out = this.output(); + var overridden = out.determinedBy; + if (overridden != null) overridden.markUnsatisfied(); + out.determinedBy = this; + if (!planner.addPropagate(this, mark)) + alert("Cycle encountered"); + out.mark = mark; + return overridden; +} + +Constraint.prototype.destroyConstraint = function () { + if (this.isSatisfied()) planner.incrementalRemove(this); + else this.removeFromGraph(); +} + +/** + * Normal constraints are not input constraints. An input constraint + * is one that depends on external state, such as the mouse, the + * keybord, a clock, or some arbitraty piece of imperative code. + */ +Constraint.prototype.isInput = function () { + return false; +} + +/* --- * + * U n a r y C o n s t r a i n t + * --- */ + +/** + * Abstract superclass for constraints having a single possible output + * variable. + */ +function UnaryConstraint(v, strength) { + UnaryConstraint.superConstructor.call(this, strength); + this.myOutput = v; + this.satisfied = false; + this.addConstraint(); +} + +UnaryConstraint.inheritsFrom(Constraint); + +/** + * Adds this constraint to the constraint graph + */ +UnaryConstraint.prototype.addToGraph = function () { + this.myOutput.addConstraint(this); + this.satisfied = false; +} + +/** + * Decides if this constraint can be satisfied and records that + * decision. + */ +UnaryConstraint.prototype.chooseMethod = function (mark) { + this.satisfied = (this.myOutput.mark != mark) + && Strength.stronger(this.strength, this.myOutput.walkStrength); +} + +/** + * Returns true if this constraint is satisfied in the current solution. + */ +UnaryConstraint.prototype.isSatisfied = function () { + return this.satisfied; +} + +UnaryConstraint.prototype.markInputs = function (mark) { + // has no inputs +} + +/** + * Returns the current output variable. + */ +UnaryConstraint.prototype.output = function () { + return this.myOutput; +} + +/** + * Calculate the walkabout strength, the stay flag, and, if it is + * 'stay', the value for the current output of this constraint. Assume + * this constraint is satisfied. + */ +UnaryConstraint.prototype.recalculate = function () { + this.myOutput.walkStrength = this.strength; + this.myOutput.stay = !this.isInput(); + if (this.myOutput.stay) this.execute(); // Stay optimization +} + +/** + * Records that this constraint is unsatisfied + */ +UnaryConstraint.prototype.markUnsatisfied = function () { + this.satisfied = false; +} + +UnaryConstraint.prototype.inputsKnown = function () { + return true; +} + +UnaryConstraint.prototype.removeFromGraph = function () { + if (this.myOutput != null) this.myOutput.removeConstraint(this); + this.satisfied = false; +} + +/* --- * + * S t a y C o n s t r a i n t + * --- */ + +/** + * Variables that should, with some level of preference, stay the same. + * Planners may exploit the fact that instances, if satisfied, will not + * change their output during plan execution. This is called "stay + * optimization". + */ +function StayConstraint(v, str) { + StayConstraint.superConstructor.call(this, v, str); +} + +StayConstraint.inheritsFrom(UnaryConstraint); + +StayConstraint.prototype.execute = function () { + // Stay constraints do nothing +} + +/* --- * + * E d i t C o n s t r a i n t + * --- */ + +/** + * A unary input constraint used to mark a variable that the client + * wishes to change. + */ +function EditConstraint(v, str) { + EditConstraint.superConstructor.call(this, v, str); +} + +EditConstraint.inheritsFrom(UnaryConstraint); + +/** + * Edits indicate that a variable is to be changed by imperative code. + */ +EditConstraint.prototype.isInput = function () { + return true; +} + +EditConstraint.prototype.execute = function () { + // Edit constraints do nothing +} + +/* --- * + * B i n a r y C o n s t r a i n t + * --- */ + +var Direction = new Object(); +Direction.NONE = 0; +Direction.FORWARD = 1; +Direction.BACKWARD = -1; + +/** + * Abstract superclass for constraints having two possible output + * variables. + */ +function BinaryConstraint(var1, var2, strength) { + BinaryConstraint.superConstructor.call(this, strength); + this.v1 = var1; + this.v2 = var2; + this.direction = Direction.NONE; + this.addConstraint(); +} + +BinaryConstraint.inheritsFrom(Constraint); + +/** + * Decides if this constraint can be satisfied and which way it + * should flow based on the relative strength of the variables related, + * and record that decision. + */ +BinaryConstraint.prototype.chooseMethod = function (mark) { + if (this.v1.mark == mark) { + this.direction = (this.v2.mark != mark && Strength.stronger(this.strength, this.v2.walkStrength)) + ? Direction.FORWARD + : Direction.NONE; + } + if (this.v2.mark == mark) { + this.direction = (this.v1.mark != mark && Strength.stronger(this.strength, this.v1.walkStrength)) + ? Direction.BACKWARD + : Direction.NONE; + } + if (Strength.weaker(this.v1.walkStrength, this.v2.walkStrength)) { + this.direction = Strength.stronger(this.strength, this.v1.walkStrength) + ? Direction.BACKWARD + : Direction.NONE; + } else { + this.direction = Strength.stronger(this.strength, this.v2.walkStrength) + ? Direction.FORWARD + : Direction.BACKWARD + } +} + +/** + * Add this constraint to the constraint graph + */ +BinaryConstraint.prototype.addToGraph = function () { + this.v1.addConstraint(this); + this.v2.addConstraint(this); + this.direction = Direction.NONE; +} + +/** + * Answer true if this constraint is satisfied in the current solution. + */ +BinaryConstraint.prototype.isSatisfied = function () { + return this.direction != Direction.NONE; +} + +/** + * Mark the input variable with the given mark. + */ +BinaryConstraint.prototype.markInputs = function (mark) { + this.input().mark = mark; +} + +/** + * Returns the current input variable + */ +BinaryConstraint.prototype.input = function () { + return (this.direction == Direction.FORWARD) ? this.v1 : this.v2; +} + +/** + * Returns the current output variable + */ +BinaryConstraint.prototype.output = function () { + return (this.direction == Direction.FORWARD) ? this.v2 : this.v1; +} + +/** + * Calculate the walkabout strength, the stay flag, and, if it is + * 'stay', the value for the current output of this + * constraint. Assume this constraint is satisfied. + */ +BinaryConstraint.prototype.recalculate = function () { + var ihn = this.input(), out = this.output(); + out.walkStrength = Strength.weakestOf(this.strength, ihn.walkStrength); + out.stay = ihn.stay; + if (out.stay) this.execute(); +} + +/** + * Record the fact that this constraint is unsatisfied. + */ +BinaryConstraint.prototype.markUnsatisfied = function () { + this.direction = Direction.NONE; +} + +BinaryConstraint.prototype.inputsKnown = function (mark) { + var i = this.input(); + return i.mark == mark || i.stay || i.determinedBy == null; +} + +BinaryConstraint.prototype.removeFromGraph = function () { + if (this.v1 != null) this.v1.removeConstraint(this); + if (this.v2 != null) this.v2.removeConstraint(this); + this.direction = Direction.NONE; +} + +/* --- * + * S c a l e C o n s t r a i n t + * --- */ + +/** + * Relates two variables by the linear scaling relationship: "v2 = + * (v1 * scale) + offset". Either v1 or v2 may be changed to maintain + * this relationship but the scale factor and offset are considered + * read-only. + */ +function ScaleConstraint(src, scale, offset, dest, strength) { + this.direction = Direction.NONE; + this.scale = scale; + this.offset = offset; + ScaleConstraint.superConstructor.call(this, src, dest, strength); +} + +ScaleConstraint.inheritsFrom(BinaryConstraint); + +/** + * Adds this constraint to the constraint graph. + */ +ScaleConstraint.prototype.addToGraph = function () { + ScaleConstraint.superConstructor.prototype.addToGraph.call(this); + this.scale.addConstraint(this); + this.offset.addConstraint(this); +} + +ScaleConstraint.prototype.removeFromGraph = function () { + ScaleConstraint.superConstructor.prototype.removeFromGraph.call(this); + if (this.scale != null) this.scale.removeConstraint(this); + if (this.offset != null) this.offset.removeConstraint(this); +} + +ScaleConstraint.prototype.markInputs = function (mark) { + ScaleConstraint.superConstructor.prototype.markInputs.call(this, mark); + this.scale.mark = this.offset.mark = mark; +} + +/** + * Enforce this constraint. Assume that it is satisfied. + */ +ScaleConstraint.prototype.execute = function () { + if (this.direction == Direction.FORWARD) { + this.v2.value = this.v1.value * this.scale.value + this.offset.value; + } else { + this.v1.value = (this.v2.value - this.offset.value) / this.scale.value; + } +} + +/** + * Calculate the walkabout strength, the stay flag, and, if it is + * 'stay', the value for the current output of this constraint. Assume + * this constraint is satisfied. + */ +ScaleConstraint.prototype.recalculate = function () { + var ihn = this.input(), out = this.output(); + out.walkStrength = Strength.weakestOf(this.strength, ihn.walkStrength); + out.stay = ihn.stay && this.scale.stay && this.offset.stay; + if (out.stay) this.execute(); +} + +/* --- * + * E q u a l i t y C o n s t r a i n t + * --- */ + +/** + * Constrains two variables to have the same value. + */ +function EqualityConstraint(var1, var2, strength) { + EqualityConstraint.superConstructor.call(this, var1, var2, strength); +} + +EqualityConstraint.inheritsFrom(BinaryConstraint); + +/** + * Enforce this constraint. Assume that it is satisfied. + */ +EqualityConstraint.prototype.execute = function () { + this.output().value = this.input().value; +} + +/* --- * + * V a r i a b l e + * --- */ + +/** + * A constrained variable. In addition to its value, it maintain the + * structure of the constraint graph, the current dataflow graph, and + * various parameters of interest to the DeltaBlue incremental + * constraint solver. + **/ +function Variable(name, initialValue) { + this.value = initialValue || 0; + this.constraints = new OrderedCollection(); + this.determinedBy = null; + this.mark = 0; + this.walkStrength = Strength.WEAKEST; + this.stay = true; + this.name = name; +} + +/** + * Add the given constraint to the set of all constraints that refer + * this variable. + */ +Variable.prototype.addConstraint = function (c) { + this.constraints.add(c); +} + +/** + * Removes all traces of c from this variable. + */ +Variable.prototype.removeConstraint = function (c) { + this.constraints.remove(c); + if (this.determinedBy == c) this.determinedBy = null; +} + +/* --- * + * P l a n n e r + * --- */ + +/** + * The DeltaBlue planner + */ +function Planner() { + this.currentMark = 0; +} + +/** + * Attempt to satisfy the given constraint and, if successful, + * incrementally update the dataflow graph. Details: If satifying + * the constraint is successful, it may override a weaker constraint + * on its output. The algorithm attempts to resatisfy that + * constraint using some other method. This process is repeated + * until either a) it reaches a variable that was not previously + * determined by any constraint or b) it reaches a constraint that + * is too weak to be satisfied using any of its methods. The + * variables of constraints that have been processed are marked with + * a unique mark value so that we know where we've been. This allows + * the algorithm to avoid getting into an infinite loop even if the + * constraint graph has an inadvertent cycle. + */ +Planner.prototype.incrementalAdd = function (c) { + var mark = this.newMark(); + var overridden = c.satisfy(mark); + while (overridden != null) + overridden = overridden.satisfy(mark); +} + +/** + * Entry point for retracting a constraint. Remove the given + * constraint and incrementally update the dataflow graph. + * Details: Retracting the given constraint may allow some currently + * unsatisfiable downstream constraint to be satisfied. We therefore collect + * a list of unsatisfied downstream constraints and attempt to + * satisfy each one in turn. This list is traversed by constraint + * strength, strongest first, as a heuristic for avoiding + * unnecessarily adding and then overriding weak constraints. + * Assume: c is satisfied. + */ +Planner.prototype.incrementalRemove = function (c) { + var out = c.output(); + c.markUnsatisfied(); + c.removeFromGraph(); + var unsatisfied = this.removePropagateFrom(out); + var strength = Strength.REQUIRED; + do { + for (var i = 0; i < unsatisfied.size(); i++) { + var u = unsatisfied.at(i); + if (u.strength == strength) + this.incrementalAdd(u); + } + strength = strength.nextWeaker(); + } while (strength != Strength.WEAKEST); +} + +/** + * Select a previously unused mark value. + */ +Planner.prototype.newMark = function () { + return ++this.currentMark; +} + +/** + * Extract a plan for resatisfaction starting from the given source + * constraints, usually a set of input constraints. This method + * assumes that stay optimization is desired; the plan will contain + * only constraints whose output variables are not stay. Constraints + * that do no computation, such as stay and edit constraints, are + * not included in the plan. + * Details: The outputs of a constraint are marked when it is added + * to the plan under construction. A constraint may be appended to + * the plan when all its input variables are known. A variable is + * known if either a) the variable is marked (indicating that has + * been computed by a constraint appearing earlier in the plan), b) + * the variable is 'stay' (i.e. it is a constant at plan execution + * time), or c) the variable is not determined by any + * constraint. The last provision is for past states of history + * variables, which are not stay but which are also not computed by + * any constraint. + * Assume: sources are all satisfied. + */ +Planner.prototype.makePlan = function (sources) { + var mark = this.newMark(); + var plan = new Plan(); + var todo = sources; + while (todo.size() > 0) { + var c = todo.removeFirst(); + if (c.output().mark != mark && c.inputsKnown(mark)) { + plan.addConstraint(c); + c.output().mark = mark; + this.addConstraintsConsumingTo(c.output(), todo); + } + } + return plan; +} + +/** + * Extract a plan for resatisfying starting from the output of the + * given constraints, usually a set of input constraints. + */ +Planner.prototype.extractPlanFromConstraints = function (constraints) { + var sources = new OrderedCollection(); + for (var i = 0; i < constraints.size(); i++) { + var c = constraints.at(i); + if (c.isInput() && c.isSatisfied()) + // not in plan already and eligible for inclusion + sources.add(c); + } + return this.makePlan(sources); +} + +/** + * Recompute the walkabout strengths and stay flags of all variables + * downstream of the given constraint and recompute the actual + * values of all variables whose stay flag is true. If a cycle is + * detected, remove the given constraint and answer + * false. Otherwise, answer true. + * Details: Cycles are detected when a marked variable is + * encountered downstream of the given constraint. The sender is + * assumed to have marked the inputs of the given constraint with + * the given mark. Thus, encountering a marked node downstream of + * the output constraint means that there is a path from the + * constraint's output to one of its inputs. + */ +Planner.prototype.addPropagate = function (c, mark) { + var todo = new OrderedCollection(); + todo.add(c); + while (todo.size() > 0) { + var d = todo.removeFirst(); + if (d.output().mark == mark) { + this.incrementalRemove(c); + return false; + } + d.recalculate(); + this.addConstraintsConsumingTo(d.output(), todo); + } + return true; +} + + +/** + * Update the walkabout strengths and stay flags of all variables + * downstream of the given constraint. Answer a collection of + * unsatisfied constraints sorted in order of decreasing strength. + */ +Planner.prototype.removePropagateFrom = function (out) { + out.determinedBy = null; + out.walkStrength = Strength.WEAKEST; + out.stay = true; + var unsatisfied = new OrderedCollection(); + var todo = new OrderedCollection(); + todo.add(out); + while (todo.size() > 0) { + var v = todo.removeFirst(); + for (var i = 0; i < v.constraints.size(); i++) { + var c = v.constraints.at(i); + if (!c.isSatisfied()) + unsatisfied.add(c); + } + var determining = v.determinedBy; + for (var i = 0; i < v.constraints.size(); i++) { + var next = v.constraints.at(i); + if (next != determining && next.isSatisfied()) { + next.recalculate(); + todo.add(next.output()); + } + } + } + return unsatisfied; +} + +Planner.prototype.addConstraintsConsumingTo = function (v, coll) { + var determining = v.determinedBy; + var cc = v.constraints; + for (var i = 0; i < cc.size(); i++) { + var c = cc.at(i); + if (c != determining && c.isSatisfied()) + coll.add(c); + } +} + +/* --- * + * P l a n + * --- */ + +/** + * A Plan is an ordered list of constraints to be executed in sequence + * to resatisfy all currently satisfiable constraints in the face of + * one or more changing inputs. + */ +function Plan() { + this.v = new OrderedCollection(); +} + +Plan.prototype.addConstraint = function (c) { + this.v.add(c); +} + +Plan.prototype.size = function () { + return this.v.size(); +} + +Plan.prototype.constraintAt = function (index) { + return this.v.at(index); +} + +Plan.prototype.execute = function () { + for (var i = 0; i < this.size(); i++) { + var c = this.constraintAt(i); + c.execute(); + } +} + +/* --- * + * M a i n + * --- */ + +/** + * This is the standard DeltaBlue benchmark. A long chain of equality + * constraints is constructed with a stay constraint on one end. An + * edit constraint is then added to the opposite end and the time is + * measured for adding and removing this constraint, and extracting + * and executing a constraint satisfaction plan. There are two cases. + * In case 1, the added constraint is stronger than the stay + * constraint and values must propagate down the entire length of the + * chain. In case 2, the added constraint is weaker than the stay + * constraint so it cannot be accomodated. The cost in this case is, + * of course, very low. Typical situations lie somewhere between these + * two extremes. + */ +function chainTest(n) { + planner = new Planner(); + var prev = null, first = null, last = null; + + // Build chain of n equality constraints + for (var i = 0; i <= n; i++) { + var name = "v" + i; + var v = new Variable(name); + if (prev != null) + new EqualityConstraint(prev, v, Strength.REQUIRED); + if (i == 0) first = v; + if (i == n) last = v; + prev = v; + } + + new StayConstraint(last, Strength.STRONG_DEFAULT); + var edit = new EditConstraint(first, Strength.PREFERRED); + var edits = new OrderedCollection(); + edits.add(edit); + + return function() { + var plan = planner.extractPlanFromConstraints(edits); + for (var i = 0; i < 100; i++) { + first.value = i; + plan.execute(); + if (last.value != i) + alert("Chain test failed."); + } + } +} + +/** + * This test constructs a two sets of variables related to each + * other by a simple linear transformation (scale and offset). The + * time is measured to change a variable on either side of the + * mapping and to change the scale and offset factors. + */ +function projectionTest(n) { + planner = new Planner(); + var scale = new Variable("scale", 10); + var offset = new Variable("offset", 1000); + var src = null, dst = null; + + var dests = new OrderedCollection(); + for (var i = 0; i < n; i++) { + src = new Variable("src" + i, i); + dst = new Variable("dst" + i, i); + dests.add(dst); + new StayConstraint(src, Strength.NORMAL); + new ScaleConstraint(src, scale, offset, dst, Strength.REQUIRED); + } + + return function() { + change(src, 17); + if (dst.value != 1170) alert("Projection 1 failed"); + change(dst, 1050); + if (src.value != 5) alert("Projection 2 failed"); + change(scale, 5); + for (var i = 0; i < n - 1; i++) { + if (dests.at(i).value != i * 5 + 1000) + alert("Projection 3 failed"); + } + change(offset, 2000); + for (var i = 0; i < n - 1; i++) { + if (dests.at(i).value != i * 5 + 2000) + alert("Projection 4 failed"); + } + } +} + +function change(v, newValue) { + var edit = new EditConstraint(v, Strength.PREFERRED); + var edits = new OrderedCollection(); + edits.add(edit); + var plan = planner.extractPlanFromConstraints(edits); + for (var i = 0; i < 10; i++) { + v.value = newValue; + plan.execute(); + } + edit.destroyConstraint(); +} + +// Global variable holding the current planner. +var planner = null; + +function deltaBlue() { + chainTest(100)(); + projectionTest(100)(); +} diff --git a/tests/benchmarks/qml/deltablue/main.cpp b/tests/benchmarks/qml/deltablue/main.cpp new file mode 100644 index 0000000000..727c740fb6 --- /dev/null +++ b/tests/benchmarks/qml/deltablue/main.cpp @@ -0,0 +1,68 @@ +// Copyright (C) 2023 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only + +#include <QtQml/qqmlapplicationengine.h> +#include <QtQml/qqmlcomponent.h> + +#include <QtTest/qbenchmark.h> +#include <QtTest/qtest.h> +#include <QtTest/qtestcase.h> + +class DeltaBlue : public QObject +{ + Q_OBJECT +public: + +private slots: + void qml() { + QBENCHMARK { + QObject *instance = engine.singletonInstance<QObject *>( + "DeltaBlue", "Main"); + QMetaObject::invokeMethod(instance, "deltaBlue"); + engine.clearSingletons(); + } + } + + void nicer() { + QQmlComponent chain(&engine, "DeltaBlue", "ChainTest"); + QQmlComponent projection(&engine, "DeltaBlue", "ProjectionTest"); + QBENCHMARK { + QScopedPointer<QObject> chainTest(chain.create()); + QMetaObject::invokeMethod(chainTest.data(), "run"); + + QScopedPointer<QObject> projectionTest(projection.create()); + QMetaObject::invokeMethod(projectionTest.data(), "run"); + } + } + + void onlyCreate() { + QQmlComponent chain(&engine, "DeltaBlue", "ChainTest"); + QQmlComponent projection(&engine, "DeltaBlue", "ProjectionTest"); + QBENCHMARK { + QScopedPointer<QObject> chainTest(chain.create()); + QScopedPointer<QObject> projectionTest(projection.create()); + } + } + + void js() { + QQmlComponent main2(&engine, "DeltaBlue", "Main2"); + QBENCHMARK { + QScopedPointer<QObject> instance(main2.create()); + QMetaObject::invokeMethod(instance.data(), "deltaBlue"); + } + } + + void jsOnlyCreate() { + QQmlComponent main2(&engine, "DeltaBlue", "Main2"); + QBENCHMARK { + QScopedPointer<QObject> instance(main2.create()); + } + } + +private: + QQmlApplicationEngine engine; +}; + +QTEST_MAIN(DeltaBlue) + +#include "main.moc" |