cerc-io/solidity
16
0
Fork 0
mirror of https://github.com/ethereum/solidity synced 2023-10-03 13:03:40 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge pull request #7801 from ethereum/tuneRemat

Browse Source 
Tune rematerializer
This commit is contained in:
chriseth 2020-01-08 10:41:32 +01:00 committed by GitHub
commit b5bd4787af
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
16 changed files with 196 additions and 33 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
Changelog.md
View File

@ -5,6 +5,7 @@ Language Features:
Compiler Features:
* General: Raise warning if runtime bytecode exceeds 24576 bytes (a limit introduced in Spurious Dragon).
* Yul Optimizer: Apply penalty when trying to rematerialize into loops.
Bugfixes:

27
libyul/optimiser/DataFlowAnalyzer.cpp
View File

@ -145,10 +145,14 @@ void DataFlowAnalyzer::operator()(FunctionDefinition& _fun)
// Save all information. We might rather reinstantiate this class,
// but this could be difficult if it is subclassed.
map<YulString, Expression const*> value;
map<YulString, size_t> variableLoopDepth;
size_t loopDepth{0};
InvertibleRelation<YulString> references;
InvertibleMap<YulString, YulString> storage;
InvertibleMap<YulString, YulString> memory;
m_value.swap(value);
swap(m_value, value);
swap(m_variableLoopDepth, variableLoopDepth);
swap(m_loopDepth, loopDepth);
swap(m_references, references);
swap(m_storage, storage);
swap(m_memory, memory);
@ -168,7 +172,9 @@ void DataFlowAnalyzer::operator()(FunctionDefinition& _fun)
// statement.
popScope();
m_value.swap(value);
swap(m_value, value);
swap(m_variableLoopDepth, variableLoopDepth);
swap(m_loopDepth, loopDepth);
swap(m_references, references);
swap(m_storage, storage);
swap(m_memory, memory);
@ -180,6 +186,8 @@ void DataFlowAnalyzer::operator()(ForLoop& _for)
// we would have to deal with more complicated scoping rules.
assertThrow(_for.pre.statements.empty(), OptimizerException, "");
++m_loopDepth;
AssignmentsSinceContinue assignmentsSinceCont;
assignmentsSinceCont(_for.body);
@ -202,6 +210,8 @@ void DataFlowAnalyzer::operator()(ForLoop& _for)
clearKnowledgeIfInvalidated(*_for.condition);
clearKnowledgeIfInvalidated(_for.post);
clearKnowledgeIfInvalidated(_for.body);
--m_loopDepth;
}
void DataFlowAnalyzer::operator()(Block& _block)
@ -222,7 +232,7 @@ void DataFlowAnalyzer::handleAssignment(set<YulString> const& _variables, Expres
movableChecker.visit(*_value);
else
for (auto const& var: _variables)
m_value[var] = &m_zero;
assignValue(var, &m_zero);
if (_value && _variables.size() == 1)
{
@ -230,7 +240,7 @@ void DataFlowAnalyzer::handleAssignment(set<YulString> const& _variables, Expres
// Expression has to be movable and cannot contain a reference
// to the variable that will be assigned to.
if (movableChecker.movable() && !movableChecker.referencedVariables().count(name))
m_value[name] = _value;
assignValue(name, _value);
}
auto const& referencedVariables = movableChecker.referencedVariables();
@ -296,11 +306,20 @@ void DataFlowAnalyzer::clearValues(set<YulString> _variables)
// Clear the value and update the reference relation.
for (auto const& name: _variables)
{
m_value.erase(name);
m_variableLoopDepth.erase(name);
}
for (auto const& name: _variables)
m_references.eraseKey(name);
}
void DataFlowAnalyzer::assignValue(YulString _variable, Expression const* _value)
{
m_value[_variable] = _value;
m_variableLoopDepth[_variable] = m_loopDepth;
}
void DataFlowAnalyzer::clearKnowledgeIfInvalidated(Block const& _block)
{
SideEffectsCollector sideEffects(m_dialect, _block, &m_functionSideEffects);

7
libyul/optimiser/DataFlowAnalyzer.h
View File

@ -110,6 +110,8 @@ protected:
/// for example at points where control flow is merged.
void clearValues(std::set<YulString> _names);
void assignValue(YulString _variable, Expression const* _value);
/// Clears knowledge about storage or memory if they may be modified inside the block.
void clearKnowledgeIfInvalidated(Block const& _block);
@ -144,6 +146,8 @@ protected:
/// Current values of variables, always movable.
std::map<YulString, Expression const*> m_value;
/// The loop nesting depth of the definition of variables (those used in m_value).
std::map<YulString, size_t> m_variableLoopDepth;
/// m_references.forward[a].contains(b) <=> the current expression assigned to a references b
/// m_references.backward[b].contains(a) <=> the current expression assigned to a references b
InvertibleRelation<YulString> m_references;
@ -153,6 +157,9 @@ protected:
KnowledgeBase m_knowledgeBase;
/// Current nesting depth of loops.
size_t m_loopDepth{0};
struct Scope
{
explicit Scope(bool _isFunction): isFunction(_isFunction) {}

7
libyul/optimiser/Rematerialiser.cpp
View File

@ -78,7 +78,12 @@ void Rematerialiser::visit(Expression& _e)
auto const& value = *m_value.at(name);
size_t refs = m_referenceCounts[name];
size_t cost = CodeCost::codeCost(m_dialect, value);
if (refs <= 1 || cost == 0 || (refs <= 5 && cost <= 1) || m_varsToAlwaysRematerialize.count(name))
if (
(refs <= 1 && m_variableLoopDepth.at(name) == m_loopDepth) ||
cost == 0 ||
(refs <= 5 && cost <= 1 && m_loopDepth == 0) ||
m_varsToAlwaysRematerialize.count(name)
)
{
assertThrow(m_referenceCounts[name] > 0, OptimizerException, "");
for (auto const& ref: m_references.forward[name])

9
libyul/optimiser/Rematerialiser.h
View File

@ -27,12 +27,13 @@ namespace solidity::yul
{
/**
* Optimisation stage that replaces variables by their most recently assigned expressions,
* Optimisation stage that replaces variable references by those expressions
* that are most recently assigned to the referenced variables,
* but only if the expression is movable and one of the following holds:
* - the variable is referenced exactly once
* - the variable is referenced exactly once (and definition-to-reference does not cross a loop boundary)
* - the value is extremely cheap ("cost" of zero like ``caller()``)
* - the variable is referenced at most 5 times and the value is rather cheap
* ("cost" of at most 1 like a constant up to 0xff)
* ("cost" of at most 1 like a constant up to 0xff) and we are not in a loop
*
* Prerequisite: Disambiguator, ForLoopInitRewriter.
*/
@ -68,6 +69,8 @@ protected:
std::set<YulString> _varsToAlwaysRematerialize = {}
);
using DataFlowAnalyzer::operator();
using ASTModifier::visit;
void visit(Expression& _e) override;

4
test/libsolidity/gasTests/abiv2_optimised.sol
View File

@ -17,9 +17,9 @@ contract C {
// optimize-yul: true
// ----
// creation:
// codeDepositCost: 605800
// codeDepositCost: 603000
// executionCost: 638
// totalCost: 606438
// totalCost: 603638
// external:
// a(): 1029
// b(uint256): 2084

36
test/libyul/yulOptimizerTests/fullSuite/abi_example1.yul
View File

@ -492,34 +492,37 @@
// }
// function abi_decode_t_array$_t_array$_t_uint256_$2_memory_$dyn_memory_ptr(offset, end) -> array
// {
// if iszero(slt(add(offset, 0x1f), end)) { revert(array, array) }
// let _1 := 0x1f
// if iszero(slt(add(offset, _1), end)) { revert(array, array) }
// let length := calldataload(offset)
// array := allocateMemory(array_allocation_size_t_array$_t_address_$dyn_memory(length))
// let dst := array
// mstore(array, length)
// let _1 := 0x20
// dst := add(array, _1)
// let src := add(offset, _1)
// if gt(add(add(offset, mul(length, 0x40)), _1), end) { revert(0, 0) }
// let _2 := 0x20
// dst := add(array, _2)
// let src := add(offset, _2)
// let _3 := 0x40
// if gt(add(add(offset, mul(length, _3)), _2), end) { revert(0, 0) }
// let i := 0
// for { } lt(i, length) { i := add(i, 1) }
// {
// if iszero(slt(add(src, 0x1f), end)) { revert(0, 0) }
// let dst_1 := allocateMemory(array_allocation_size_t_array$_t_uint256_$2_memory(0x2))
// if iszero(slt(add(src, _1), end)) { revert(0, 0) }
// let _4 := 0x2
// let dst_1 := allocateMemory(array_allocation_size_t_array$_t_uint256_$2_memory(_4))
// let dst_2 := dst_1
// let src_1 := src
// let _2 := add(src, 0x40)
// if gt(_2, end) { revert(0, 0) }
// let _5 := add(src, _3)
// if gt(_5, end) { revert(0, 0) }
// let i_1 := 0
// for { } lt(i_1, 0x2) { i_1 := add(i_1, 1) }
// for { } lt(i_1, _4) { i_1 := add(i_1, 1) }
// {
// mstore(dst_1, calldataload(src_1))
// dst_1 := add(dst_1, _1)
// src_1 := add(src_1, _1)
// dst_1 := add(dst_1, _2)
// src_1 := add(src_1, _2)
// }
// mstore(dst, dst_2)
// dst := add(dst, _1)
// src := _2
// dst := add(dst, _2)
// src := _5
// }
// }
// function abi_decode_t_array$_t_uint256_$dyn_memory_ptr(offset, end) -> array
@ -548,8 +551,9 @@
// for { } lt(i, 0x3) { i := add(i, 1) }
// {
// mstore(pos, and(mload(srcPtr), sub(shl(160, 1), 1)))
// srcPtr := add(srcPtr, 0x20)
// pos := add(pos, 0x20)
// let _1 := 0x20
// srcPtr := add(srcPtr, _1)
// pos := add(pos, _1)
// }
// }
// function allocateMemory(size) -> memPtr

3
test/libyul/yulOptimizerTests/fullSuite/aztec.yul
View File

@ -375,7 +375,8 @@
// let i := 0
// for { } lt(i, n) { i := add(i, 0x01) }
// {
// calldatacopy(add(0x300, mul(i, 0x80)), add(add(notes, mul(i, 0xc0)), 0x60), 0x80)
// let _1 := 0x80
// calldatacopy(add(0x300, mul(i, _1)), add(add(notes, mul(i, 0xc0)), 0x60), _1)
// }
// mstore(0, keccak256(0x300, mul(n, 0x80)))
// }

11
test/libyul/yulOptimizerTests/fullSuite/clear_after_if_continue.yul
View File

@ -12,7 +12,16 @@
// {
// {
// let y := mload(0x20)
// for { } and(y, 8) { if y { revert(0, 0) } }
// let _1 := iszero(and(y, 8))
// for { }
// iszero(_1)
// {
// if y
// {
// let _2 := 0
// revert(_2, _2)
// }
// }
// {
// if y { continue }
// sstore(1, 0)

6
test/libyul/yulOptimizerTests/fullSuite/devcon_example.yul
View File

@ -21,10 +21,12 @@
// {
// let _1 := calldataload(0)
// let sum := 0
// let length := calldataload(_1)
// let i := sum
// for { } lt(i, calldataload(_1)) { i := add(i, 1) }
// for { } lt(i, length) { i := add(i, 1) }
// {
// sum := add(sum, calldataload(add(add(_1, mul(i, 0x20)), 0x20)))
// let _2 := 0x20
// sum := add(sum, calldataload(add(add(_1, mul(i, _2)), _2)))
// }
// sstore(0, sum)
// }

7
test/libyul/yulOptimizerTests/fullSuite/loopInvariantCodeMotion.yul
View File

@ -24,10 +24,13 @@
// {
// let _1 := calldataload(0)
// let sum := 0
// let length := calldataload(_1)
// let i := sum
// for { } lt(i, calldataload(_1)) { i := add(i, 1) }
// let _2 := calldataload(7)
// for { } lt(i, length) { i := add(i, 1) }
// {
// sum := add(sum, add(calldataload(add(add(_1, mul(i, 0x20)), 0x20)), calldataload(7)))
// let _3 := 0x20
// sum := add(sum, add(calldataload(add(add(_1, mul(i, _3)), _3)), _2))
// }
// sstore(0, sum)
// }

3
test/libyul/yulOptimizerTests/fullSuite/no_move_loop_orig.yul
View File

@ -12,10 +12,11 @@
// ----
// {
// {
// let _1 := iszero(caller())
// for { }
// 1
// {
// for { } caller() { }
// for { } iszero(_1) { }
// { }
// mstore(192, 0)
// }

28
test/libyul/yulOptimizerTests/rematerialiser/many_refs_small_cost_loop.yul Normal file
View File

@ -0,0 +1,28 @@
{
// Cost of rematerializating x is 1
let x := 0xff
// Although x has low cost, it is not considered for
// rematerialization because it is referenced more than 5 times
for {} lt(x, 0x100) {}
{
let y := add(x, 1)
let z := mul(x, 1)
let a := div(x, 2)
let b := mod(x, 3)
let c := sdiv(x, 4)
}
}
// ====
// step: rematerialiser
// ----
// {
// let x := 0xff
// for { } lt(x, 0x100) { }
// {
// let y := add(x, 1)
// let z := mul(x, 1)
// let a := div(x, 2)
// let b := mod(x, 3)
// let c := sdiv(x, 4)
// }
// }

37
test/libyul/yulOptimizerTests/rematerialiser/no_remat_in_loop.yul Normal file
View File

@ -0,0 +1,37 @@
{
// origin has zero cost and thus will be rematerialised,
// calldataload(0) has low cost and will not be rematerialised
let a := origin()
let b := calldataload(0)
let i := 0
let z := calldataload(9)
for {} lt(i, 10) {i := add(a, b)} {
// This will be rematerialised, because it stays inside
// the loop.
let x := calldataload(1)
mstore(9, x)
// No, because again one loop further down.
let y := calldataload(2)
for {} y {} {
// Again no.
mstore(12, z)
}
}
}
// ====
// step: rematerialiser
// ----
// {
// let a := origin()
// let b := calldataload(0)
// let i := 0
// let z := calldataload(9)
// for { } lt(i, 10) { i := add(origin(), b) }
// {
// let x := calldataload(1)
// mstore(9, calldataload(1))
// let y := calldataload(2)
// for { } y { }
// { mstore(12, z) }
// }
// }

17
test/libyul/yulOptimizerTests/rematerialiser/some_refs_small_cost_loop.yul Normal file
View File

@ -0,0 +1,17 @@
{
// Cost of rematerializating x is 1
let x := 0xff
// Reference to x is not rematerialized because the reference is in a loop
for {} lt(x, 0x100) {}
{
let y := add(x, 1)
}
}
// ====
// step: rematerialiser
// ----
// {
// let x := 0xff
// for { } lt(x, 0x100) { }
// { let y := add(x, 1) }
// }

26
test/libyul/yulOptimizerTests/rematerialiser/some_refs_small_cost_nested_loop.yul Normal file
View File

@ -0,0 +1,26 @@
{
// Cost of rematerializating x is 1
let x := 0xff
// Although x has a low cost and fewer than 6 references,
// its references in a loop are not rematerialized
for {} lt(x, 0x100) {}
{
let y := add(x, 1)
for {} lt(x, 0x200) {}
{
let z := mul(x, 2)
}
}
}
// ====
// step: rematerialiser
// ----
// {
// let x := 0xff
// for { } lt(x, 0x100) { }
// {
// let y := add(x, 1)
// for { } lt(x, 0x200) { }
// { let z := mul(x, 2) }
// }
// }