solidity/test/libsolidity/GasMeter.cpp

301 lines
7.3 KiB
C++
Raw Normal View History

2015-05-06 08:43:59 +00:00
/*
This file is part of solidity.
2015-05-06 08:43:59 +00:00
solidity is free software: you can redistribute it and/or modify
2015-05-06 08:43:59 +00:00
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
solidity is distributed in the hope that it will be useful,
2015-05-06 08:43:59 +00:00
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with solidity. If not, see <http://www.gnu.org/licenses/>.
2015-05-06 08:43:59 +00:00
*/
/**
* @author Christian <c@ethdev.com>
* @date 2015
* Unit tests for the gas estimator.
*/
2016-06-09 16:54:29 +00:00
#include <test/libsolidity/SolidityExecutionFramework.h>
Make the Solidity repository standalone. This commit is the culmination of several months of work to decouple Solidity from the webthree-umbrella so that it can be developed in parallel with cpp-ethereum (the Ethereum C++ runtime) and so that even for the Solidity unit-tests there is no hard-dependency onto the C++ runtime. The Tests-over-IPC refactoring was a major step in the same process which was already committed. This commit contains the following changes: - A subset of the CMake functionality in webthree-helpers was extracted and tailored for Solidity into ./cmake. Further cleanup is certainly possible. - A subset of the libdevcore functionality in libweb3core was extracted and tailored for Solidity into ./libdevcore. Further cleanup is certainly possible - The gas price constants in EVMSchedule were orphaned into libevmasm. - Some other refactorings and cleanups were made to sever unnecessary EVM dependencies in the Solidity unit-tests. - TravisCI and Appveyor support was added, covering builds and running of the unit-tests (Linux and macOS only for now) - A bug-fix was made to get the Tests-over-IPC running on macOS. - There are still reliability issues in the unit-tests, which need immediate attention. The Travis build has been flipped to run the unit-tests 5 times, to try to flush these out. - The Emscripten automation which was previously in webthree-umbrella was merged into the TravisCI automation here. - The development ZIP deployment step has been commented out, but we will want to read that ONLY for release branch. Further iteration on these changes will definitely be needed, but I feel these have got to sufficient maturity than holding them back further isn't winning us anything. It is go time :-)
2016-08-01 05:25:37 +00:00
#include <libevmasm/EVMSchedule.h>
#include <libevmasm/GasMeter.h>
#include <libevmasm/KnownState.h>
2015-05-22 07:33:57 +00:00
#include <libevmasm/PathGasMeter.h>
2015-10-20 22:21:52 +00:00
#include <libsolidity/ast/AST.h>
#include <libsolidity/interface/GasEstimator.h>
#include <libsolidity/interface/SourceReferenceFormatter.h>
2015-05-06 08:43:59 +00:00
using namespace std;
using namespace dev::eth;
using namespace dev::solidity;
using namespace dev::test;
2015-05-06 08:43:59 +00:00
namespace dev
{
namespace solidity
{
namespace test
{
class GasMeterTestFramework: public SolidityExecutionFramework
2015-05-06 08:43:59 +00:00
{
public:
GasMeterTestFramework() { }
void compile(string const& _sourceCode)
{
2016-08-24 10:15:35 +00:00
m_compiler.setSource("pragma solidity >= 0.0;" + _sourceCode);
2015-05-06 08:43:59 +00:00
ETH_TEST_REQUIRE_NO_THROW(m_compiler.compile(), "Compiling contract failed");
2015-08-31 16:44:29 +00:00
AssemblyItems const* items = m_compiler.runtimeAssemblyItems("");
ASTNode const& sourceUnit = m_compiler.ast();
2015-05-06 08:43:59 +00:00
BOOST_REQUIRE(items != nullptr);
2015-05-22 08:48:54 +00:00
m_gasCosts = GasEstimator::breakToStatementLevel(
GasEstimator::structuralEstimation(*items, vector<ASTNode const*>({&sourceUnit})),
2015-05-06 08:43:59 +00:00
{&sourceUnit}
);
}
2015-05-22 07:33:57 +00:00
void testCreationTimeGas(string const& _sourceCode)
{
EVMSchedule schedule;
2015-11-21 13:34:21 +00:00
compileAndRun(_sourceCode);
auto state = make_shared<KnownState>();
2015-08-31 16:44:29 +00:00
PathGasMeter meter(*m_compiler.assemblyItems());
2015-05-22 07:33:57 +00:00
GasMeter::GasConsumption gas = meter.estimateMax(0, state);
u256 bytecodeSize(m_compiler.runtimeObject().bytecode.size());
2016-06-21 16:13:07 +00:00
// costs for deployment
2015-11-21 13:34:21 +00:00
gas += bytecodeSize * schedule.createDataGas;
2016-06-21 16:13:07 +00:00
// costs for transaction
gas += gasForTransaction(m_compiler.object().bytecode, true);
BOOST_REQUIRE(!gas.isInfinite);
BOOST_CHECK(gas.value == m_gasUsed);
}
2015-05-22 08:48:54 +00:00
/// Compares the gas computed by PathGasMeter for the given signature (but unknown arguments)
/// against the actual gas usage computed by the VM on the given set of argument variants.
2015-05-26 09:29:41 +00:00
void testRunTimeGas(string const& _sig, vector<bytes> _argumentVariants)
2015-05-22 07:33:57 +00:00
{
u256 gasUsed = 0;
2016-06-21 16:13:07 +00:00
GasMeter::GasConsumption gas;
2016-10-05 10:30:28 +00:00
FixedHash<4> hash(dev::keccak256(_sig));
2015-05-22 07:33:57 +00:00
for (bytes const& arguments: _argumentVariants)
{
sendMessage(hash.asBytes() + arguments, false, 0);
gasUsed = max(gasUsed, m_gasUsed);
2016-06-21 16:13:07 +00:00
gas = max(gas, gasForTransaction(hash.asBytes() + arguments, false));
2015-05-22 07:33:57 +00:00
}
2016-06-21 16:13:07 +00:00
gas += GasEstimator::functionalEstimation(
2015-08-31 16:44:29 +00:00
*m_compiler.runtimeAssemblyItems(),
2015-05-22 08:48:54 +00:00
_sig
);
2015-05-22 07:33:57 +00:00
BOOST_REQUIRE(!gas.isInfinite);
BOOST_CHECK(gas.value == m_gasUsed);
}
2016-06-21 16:13:07 +00:00
static GasMeter::GasConsumption gasForTransaction(bytes const& _data, bool _isCreation)
{
EVMSchedule schedule;
GasMeter::GasConsumption gas = _isCreation ? schedule.txCreateGas : schedule.txGas;
for (auto i: _data)
gas += i != 0 ? schedule.txDataNonZeroGas : schedule.txDataZeroGas;
return gas;
}
2015-05-06 08:43:59 +00:00
protected:
map<ASTNode const*, eth::GasMeter::GasConsumption> m_gasCosts;
};
BOOST_FIXTURE_TEST_SUITE(GasMeterTests, GasMeterTestFramework)
BOOST_AUTO_TEST_CASE(non_overlapping_filtered_costs)
{
char const* sourceCode = R"(
contract test {
bytes x;
function f(uint a) returns (uint b) {
x.length = a;
for (; a < 200; ++a) {
x[a] = 9;
b = a * a;
}
return f(a - 1);
}
}
)";
compile(sourceCode);
for (auto first = m_gasCosts.cbegin(); first != m_gasCosts.cend(); ++first)
{
auto second = first;
for (++second; second != m_gasCosts.cend(); ++second)
2015-08-31 16:44:29 +00:00
if (first->first->location().intersects(second->first->location()))
2015-05-06 08:43:59 +00:00
{
BOOST_CHECK_MESSAGE(false, "Source locations should not overlap!");
auto scannerFromSource = [&](string const&) -> Scanner const& { return m_compiler.scanner(); };
SourceReferenceFormatter::printSourceLocation(cout, &first->first->location(), scannerFromSource);
SourceReferenceFormatter::printSourceLocation(cout, &second->first->location(), scannerFromSource);
2015-05-06 08:43:59 +00:00
}
}
}
BOOST_AUTO_TEST_CASE(simple_contract)
{
// Tests a simple "deploy contract" code without constructor. The actual contract is not relevant.
char const* sourceCode = R"(
contract test {
bytes32 public shaValue;
function f(uint a) {
shaValue = keccak256(a);
}
}
)";
testCreationTimeGas(sourceCode);
}
BOOST_AUTO_TEST_CASE(store_keccak256)
{
char const* sourceCode = R"(
contract test {
bytes32 public shaValue;
function test(uint a) {
shaValue = keccak256(a);
}
}
)";
testCreationTimeGas(sourceCode);
}
BOOST_AUTO_TEST_CASE(updating_store)
{
char const* sourceCode = R"(
contract test {
uint data;
uint data2;
function test() {
data = 1;
data = 2;
data2 = 0;
}
}
)";
testCreationTimeGas(sourceCode);
}
2015-05-22 07:33:57 +00:00
BOOST_AUTO_TEST_CASE(branches)
{
char const* sourceCode = R"(
contract test {
uint data;
uint data2;
function f(uint x) {
if (x > 7)
data2 = 1;
else
data = 1;
}
}
)";
testCreationTimeGas(sourceCode);
testRunTimeGas("f(uint256)", vector<bytes>{encodeArgs(2), encodeArgs(8)});
}
BOOST_AUTO_TEST_CASE(function_calls)
{
char const* sourceCode = R"(
contract test {
uint data;
uint data2;
function f(uint x) {
if (x > 7)
data2 = g(x**8) + 1;
else
data = 1;
}
function g(uint x) internal returns (uint) {
return data2;
}
}
)";
testCreationTimeGas(sourceCode);
testRunTimeGas("f(uint256)", vector<bytes>{encodeArgs(2), encodeArgs(8)});
}
2015-05-22 08:48:54 +00:00
BOOST_AUTO_TEST_CASE(multiple_external_functions)
{
char const* sourceCode = R"(
contract test {
uint data;
uint data2;
function f(uint x) {
if (x > 7)
data2 = g(x**8) + 1;
else
data = 1;
}
function g(uint x) returns (uint) {
return data2;
}
}
)";
testCreationTimeGas(sourceCode);
testRunTimeGas("f(uint256)", vector<bytes>{encodeArgs(2), encodeArgs(8)});
testRunTimeGas("g(uint256)", vector<bytes>{encodeArgs(2)});
}
BOOST_AUTO_TEST_CASE(exponent_size)
{
char const* sourceCode = R"(
contract A {
function g(uint x) returns (uint) {
return x ** 0x100;
}
function h(uint x) returns (uint) {
return x ** 0x10000;
}
}
)";
testCreationTimeGas(sourceCode);
testRunTimeGas("g(uint256)", vector<bytes>{encodeArgs(2)});
2017-02-24 19:09:38 +00:00
testRunTimeGas("h(uint256)", vector<bytes>{encodeArgs(2)});
}
BOOST_AUTO_TEST_CASE(balance_gas)
{
char const* sourceCode = R"(
contract A {
function lookup_balance(address a) returns (uint) {
return a.balance;
}
}
)";
testCreationTimeGas(sourceCode);
2017-02-24 19:09:38 +00:00
testRunTimeGas("lookup_balance(address)", vector<bytes>{encodeArgs(2), encodeArgs(100)});
}
BOOST_AUTO_TEST_CASE(extcodesize_gas)
{
char const* sourceCode = R"(
contract A {
function f() returns (uint _s) {
assembly {
_s := extcodesize(0x30)
}
}
}
)";
testCreationTimeGas(sourceCode);
testRunTimeGas("f()", vector<bytes>{encodeArgs()});
}
2015-05-06 08:43:59 +00:00
BOOST_AUTO_TEST_SUITE_END()
}
}
}