[PAN-3023] Add command line option for target gas limit

acceptance-tests/dsl/src/main/java/org/hyperledger/besu/tests/acceptance/dsl/node/ThreadBesuNodeRunner.java

@@ -21,6 +21,7 @@
 import org.hyperledger.besu.cli.config.EthNetworkConfig;
 import org.hyperledger.besu.controller.BesuController;
 import org.hyperledger.besu.controller.BesuControllerBuilder;
+import org.hyperledger.besu.controller.GasLimitCalculator;
 import org.hyperledger.besu.controller.KeyPairUtil;
 import org.hyperledger.besu.ethereum.api.graphql.GraphQLConfiguration;
 import org.hyperledger.besu.ethereum.eth.EthProtocolConfiguration;
@@ -148,6 +149,7 @@ public void startNode(final BesuNode node) {
               .clock(Clock.systemUTC())
               .isRevertReasonEnabled(node.isRevertReasonEnabled())
               .storageProvider(storageProvider)
+              .targetGasLimit(GasLimitCalculator.DEFAULT)
               .build();
     } catch (final IOException e) {
       throw new RuntimeException("Error building BesuController", e);

besu/src/main/java/org/hyperledger/besu/cli/BesuCommand.java

@@ -662,6 +662,12 @@ void setBannedNodeIds(final List<String> values) {
           "The name of a file containing the private key used to sign privacy marker transactions. If unset, each will be signed with a random key.")
   private final Path privacyMarkerTransactionSigningKeyPath = null;
 
+  @Option(
+      names = {"--target-gas-limit"},
+      description =
+          "Sets target gas limit per block. If set each blocks gas limit will approach this setting over time if the current gas limit is different.")
+  private final Long targetGasLimit = null;
+
   @Option(
       names = {"--tx-pool-max-size"},
       paramLabel = MANDATORY_INTEGER_FORMAT_HELP,
@@ -1078,7 +1084,8 @@ public BesuControllerBuilder<?> getControllerBuilder() {
           .storageProvider(keyStorageProvider(keyValueStorageName))
           .isPruningEnabled(isPruningEnabled)
           .pruningConfiguration(buildPruningConfiguration())
-          .genesisConfigOverrides(genesisConfigOverrides);
+          .genesisConfigOverrides(genesisConfigOverrides)
+          .targetGasLimit(targetGasLimit == null ? Optional.empty() : Optional.of(targetGasLimit));
     } catch (final IOException e) {
       throw new ExecutionException(this.commandLine, "Invalid path", e);
     }

besu/src/main/java/org/hyperledger/besu/controller/BesuControllerBuilder.java

@@ -84,6 +84,7 @@ public abstract class BesuControllerBuilder<C> {
   protected Clock clock;
   protected KeyPair nodeKeys;
   protected boolean isRevertReasonEnabled;
+  protected GasLimitCalculator gasLimitCalculator;
   private StorageProvider storageProvider;
   private final List<Runnable> shutdownActions = new ArrayList<>();
   private boolean isPruningEnabled;
@@ -181,6 +182,11 @@ public BesuControllerBuilder<C> genesisConfigOverrides(
     return this;
   }
 
+  public BesuControllerBuilder<C> targetGasLimit(final Optional<Long> targetGasLimit) {
+    this.gasLimitCalculator = new GasLimitCalculator(targetGasLimit);
+    return this;
+  }
+
   public BesuController<C> build() {
     checkNotNull(genesisConfig, "Missing genesis config");
     checkNotNull(syncConfig, "Missing sync config");
@@ -194,6 +200,7 @@ public BesuController<C> build() {
     checkNotNull(transactionPoolConfiguration, "Missing transaction pool configuration");
     checkNotNull(nodeKeys, "Missing node keys");
     checkNotNull(storageProvider, "Must supply a storage provider");
+    checkNotNull(gasLimitCalculator, "Missing gas limit calculator");
 
     prepForBuild();
 

besu/src/main/java/org/hyperledger/besu/controller/CliqueBesuControllerBuilder.java

@@ -96,7 +96,8 @@ protected MiningCoordinator createMiningCoordinator(
                 protocolContext.getConsensusState().getVoteTallyCache(),
                 localAddress,
                 secondsBetweenBlocks),
-            epochManager);
+            epochManager,
+            gasLimitCalculator);
     final CliqueMiningCoordinator miningCoordinator =
         new CliqueMiningCoordinator(
             protocolContext.getBlockchain(),

besu/src/main/java/org/hyperledger/besu/controller/GasLimitCalculator.java

@@ -0,0 +1,75 @@
+/*
+ * Copyright 2019 ConsenSys AG.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+package org.hyperledger.besu.controller;
+
+import java.util.Optional;
+import java.util.function.Function;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+public class GasLimitCalculator implements Function<Long, Long> {
+  private static final Logger LOG = LogManager.getLogger();
+  public static final long ADJUSTMENT_FACTOR = 1024L;
+  public static final Optional<Long> DEFAULT = Optional.empty();
+  private final Optional<Long> targetGasLimit;
+
+  public GasLimitCalculator(final Optional<Long> targetGasLimit) {
+    if (targetGasLimit.orElse(0L) < 0L) {
+      throw new IllegalArgumentException("Invalid target gas limit");
+    }
+
+    this.targetGasLimit = targetGasLimit;
+  }
+
+  @Override
+  public Long apply(final Long gasLimit) {
+    long newGasLimit =
+        targetGasLimit
+            .map(
+                target -> {
+                  if (target > gasLimit) {
+                    return Math.min(target, safeAdd(gasLimit));
+                  } else if (target < gasLimit) {
+                    return Math.max(target, safeSub(gasLimit));
+                  } else {
+                    return gasLimit;
+                  }
+                })
+            .orElse(gasLimit);
+
+    if (newGasLimit != gasLimit) {
+      LOG.debug("Adjusting block gas limit from {} to {}", gasLimit, newGasLimit);
+    }
+
+    return newGasLimit;
+  }
+
+  private long safeAdd(final long gasLimit) {
+    try {
+      return Math.addExact(gasLimit, ADJUSTMENT_FACTOR);
+    } catch (final ArithmeticException ex) {
+      return Long.MAX_VALUE;
+    }
+  }
+
+  private long safeSub(final long gasLimit) {
+    try {
+      return Math.max(Math.subtractExact(gasLimit, ADJUSTMENT_FACTOR), 0);
+    } catch (final ArithmeticException ex) {
+      return 0;
+    }
+  }
+}

besu/src/main/java/org/hyperledger/besu/controller/IbftBesuControllerBuilder.java

@@ -113,7 +113,7 @@ protected MiningCoordinator createMiningCoordinator(
 
     final IbftBlockCreatorFactory blockCreatorFactory =
         new IbftBlockCreatorFactory(
-            (gasLimit) -> gasLimit,
+            gasLimitCalculator,
             transactionPool.getPendingTransactions(),
             protocolContext,
             protocolSchedule,

besu/src/main/java/org/hyperledger/besu/controller/MainnetBesuControllerBuilder.java

@@ -58,7 +58,8 @@ protected MiningCoordinator createMiningCoordinator(
             new DefaultBlockScheduler(
                 MainnetBlockHeaderValidator.MINIMUM_SECONDS_SINCE_PARENT,
                 MainnetBlockHeaderValidator.TIMESTAMP_TOLERANCE_S,
-                clock));
+                clock),
+            gasLimitCalculator);
 
     final EthHashMiningCoordinator miningCoordinator =
         new EthHashMiningCoordinator(protocolContext.getBlockchain(), executor, syncState);

besu/src/test/java/org/hyperledger/besu/PrivacyTest.java

@@ -18,6 +18,7 @@
 
 import org.hyperledger.besu.config.GenesisConfigFile;
 import org.hyperledger.besu.controller.BesuController;
+import org.hyperledger.besu.controller.GasLimitCalculator;
 import org.hyperledger.besu.crypto.SECP256K1.KeyPair;
 import org.hyperledger.besu.ethereum.core.Account;
 import org.hyperledger.besu.ethereum.core.Address;
@@ -80,6 +81,7 @@ public void privacyPrecompiled() throws IOException {
             .clock(TestClock.fixed())
             .privacyParameters(privacyParameters)
             .transactionPoolConfiguration(TransactionPoolConfiguration.builder().build())
+            .targetGasLimit(GasLimitCalculator.DEFAULT)
             .build();
 
     final Address privacyContractAddress = Address.privacyPrecompiled(ADDRESS);

besu/src/test/java/org/hyperledger/besu/RunnerTest.java

@@ -23,6 +23,7 @@
 import org.hyperledger.besu.config.GenesisConfigFile;
 import org.hyperledger.besu.config.JsonUtil;
 import org.hyperledger.besu.controller.BesuController;
+import org.hyperledger.besu.controller.GasLimitCalculator;
 import org.hyperledger.besu.controller.KeyPairUtil;
 import org.hyperledger.besu.controller.MainnetBesuControllerBuilder;
 import org.hyperledger.besu.crypto.SECP256K1.KeyPair;
@@ -149,6 +150,7 @@ private void syncFromGenesis(final SyncMode mode, final GenesisConfigFile genesi
             .clock(TestClock.fixed())
             .transactionPoolConfiguration(TransactionPoolConfiguration.builder().build())
             .storageProvider(createKeyValueStorageProvider(dataDirAhead, dbAhead))
+            .targetGasLimit(GasLimitCalculator.DEFAULT)
             .build()) {
       setupState(blockCount, controller.getProtocolSchedule(), controller.getProtocolContext());
     }
@@ -168,6 +170,7 @@ private void syncFromGenesis(final SyncMode mode, final GenesisConfigFile genesi
             .clock(TestClock.fixed())
             .transactionPoolConfiguration(TransactionPoolConfiguration.builder().build())
             .storageProvider(createKeyValueStorageProvider(dataDirAhead, dbAhead))
+            .targetGasLimit(GasLimitCalculator.DEFAULT)
             .build();
     final String listenHost = InetAddress.getLoopbackAddress().getHostAddress();
     final JsonRpcConfiguration aheadJsonRpcConfiguration = jsonRpcConfiguration();
@@ -226,6 +229,7 @@ private void syncFromGenesis(final SyncMode mode, final GenesisConfigFile genesi
               .privacyParameters(PrivacyParameters.DEFAULT)
               .clock(TestClock.fixed())
               .transactionPoolConfiguration(TransactionPoolConfiguration.builder().build())
+              .targetGasLimit(GasLimitCalculator.DEFAULT)
               .build();
       final EnodeURL enode = runnerAhead.getLocalEnode().get();
       final EthNetworkConfig behindEthNetworkConfiguration =

besu/src/test/java/org/hyperledger/besu/chainexport/RlpBlockExporterTest.java

@@ -20,6 +20,7 @@
 import org.hyperledger.besu.chainimport.RlpBlockImporter;
 import org.hyperledger.besu.config.GenesisConfigFile;
 import org.hyperledger.besu.controller.BesuController;
+import org.hyperledger.besu.controller.GasLimitCalculator;
 import org.hyperledger.besu.crypto.SECP256K1.KeyPair;
 import org.hyperledger.besu.ethereum.chain.Blockchain;
 import org.hyperledger.besu.ethereum.core.Block;
@@ -90,6 +91,7 @@ private static BesuController<?> createController() throws IOException {
         .dataDirectory(dataDir)
         .clock(TestClock.fixed())
         .transactionPoolConfiguration(TransactionPoolConfiguration.builder().build())
+        .targetGasLimit(GasLimitCalculator.DEFAULT)
         .build();
   }
 

besu/src/test/java/org/hyperledger/besu/chainimport/JsonBlockImporterTest.java

@@ -21,6 +21,7 @@
 import org.hyperledger.besu.config.GenesisConfigFile;
 import org.hyperledger.besu.config.JsonUtil;
 import org.hyperledger.besu.controller.BesuController;
+import org.hyperledger.besu.controller.GasLimitCalculator;
 import org.hyperledger.besu.crypto.SECP256K1.KeyPair;
 import org.hyperledger.besu.ethereum.chain.Blockchain;
 import org.hyperledger.besu.ethereum.core.Address;
@@ -427,6 +428,7 @@ protected BesuController<?> createController(final GenesisConfigFile genesisConf
         .dataDirectory(dataDir)
         .clock(TestClock.fixed())
         .transactionPoolConfiguration(TransactionPoolConfiguration.builder().build())
+        .targetGasLimit(GasLimitCalculator.DEFAULT)
         .build();
   }
 }

besu/src/test/java/org/hyperledger/besu/chainimport/RlpBlockImporterTest.java

@@ -19,6 +19,7 @@
 
 import org.hyperledger.besu.config.GenesisConfigFile;
 import org.hyperledger.besu.controller.BesuController;
+import org.hyperledger.besu.controller.GasLimitCalculator;
 import org.hyperledger.besu.crypto.SECP256K1.KeyPair;
 import org.hyperledger.besu.ethereum.core.InMemoryStorageProvider;
 import org.hyperledger.besu.ethereum.core.MiningParametersTestBuilder;
@@ -68,6 +69,7 @@ public void blockImport() throws IOException {
             .dataDirectory(dataDir)
             .clock(TestClock.fixed())
             .transactionPoolConfiguration(TransactionPoolConfiguration.builder().build())
+            .targetGasLimit(GasLimitCalculator.DEFAULT)
             .build();
     final RlpBlockImporter.ImportResult result =
         rlpBlockImporter.importBlockchain(source, targetController);
@@ -107,6 +109,7 @@ public void ibftImport() throws IOException {
             .dataDirectory(dataDir)
             .clock(TestClock.fixed())
             .transactionPoolConfiguration(TransactionPoolConfiguration.builder().build())
+            .targetGasLimit(GasLimitCalculator.DEFAULT)
             .build();
     final RlpBlockImporter.ImportResult result =
         rlpBlockImporter.importBlockchain(source, controller);

besu/src/test/java/org/hyperledger/besu/cli/BesuCommandTest.java

@@ -176,6 +176,7 @@ public void callingBesuCommandWithoutOptionsMustSyncWithDefaultValues() throws E
     verify(mockControllerBuilder).miningParameters(miningArg.capture());
     verify(mockControllerBuilder).nodePrivateKeyFile(isNotNull());
     verify(mockControllerBuilder).storageProvider(storageProviderArgumentCaptor.capture());
+    verify(mockControllerBuilder).targetGasLimit(eq(Optional.empty()));
     verify(mockControllerBuilder).build();
 
     assertThat(storageProviderArgumentCaptor.getValue()).isNotNull();
@@ -2753,4 +2754,38 @@ public void tomlThatHasInvalidOptions() throws IOException {
     assertThat(commandErrorOutput.toString())
         .contains("Unknown options in TOML configuration file: invalid_option, invalid_option2");
   }
+
+  @Test
+  public void targetGasLimitIsEnabledWhenSpecified() throws Exception {
+    parseCommand("--target-gas-limit=10000000");
+
+    @SuppressWarnings("unchecked")
+    final ArgumentCaptor<Optional<Long>> targetGasLimitArg =
+        ArgumentCaptor.forClass(Optional.class);
+
+    verify(mockControllerBuilder).targetGasLimit(targetGasLimitArg.capture());
+    verify(mockControllerBuilder).build();
+
+    assertThat(commandOutput.toString()).isEmpty();
+    assertThat(commandErrorOutput.toString()).isEmpty();
+
+    assertThat(targetGasLimitArg.getValue()).isEqualTo(Optional.of(10_000_000L));
+  }
+
+  @Test
+  public void targetGasLimitIsDisabledWhenNotSpecified() throws Exception {
+    parseCommand();
+
+    @SuppressWarnings("unchecked")
+    final ArgumentCaptor<Optional<Long>> targetGasLimitArg =
+        ArgumentCaptor.forClass(Optional.class);
+
+    verify(mockControllerBuilder).targetGasLimit(targetGasLimitArg.capture());
+    verify(mockControllerBuilder).build();
+
+    assertThat(commandOutput.toString()).isEmpty();
+    assertThat(commandErrorOutput.toString()).isEmpty();
+
+    assertThat(targetGasLimitArg.getValue()).isEqualTo(Optional.empty());
+  }
 }

besu/src/test/java/org/hyperledger/besu/cli/CommandTestAbstract.java

@@ -169,6 +169,7 @@ public void initMocks() throws Exception {
     when(mockControllerBuilder.isPruningEnabled(anyBoolean())).thenReturn(mockControllerBuilder);
     when(mockControllerBuilder.pruningConfiguration(any())).thenReturn(mockControllerBuilder);
     when(mockControllerBuilder.genesisConfigOverrides(any())).thenReturn(mockControllerBuilder);
+    when(mockControllerBuilder.targetGasLimit(any())).thenReturn(mockControllerBuilder);
 
     // doReturn used because of generic BesuController
     doReturn(mockController).when(mockControllerBuilder).build();

besu/src/test/java/org/hyperledger/besu/controller/GasLimitCalculatorTest.java

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2019 ConsenSys AG.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+package org.hyperledger.besu.controller;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.util.Optional;
+import java.util.function.Function;
+
+import org.junit.Test;
+
+public class GasLimitCalculatorTest {
+  @Test
+  public void verifyGasLimitIsIncreasedWithinLimits() {
+    Function<Long, Long> gasLimitCalculator = new GasLimitCalculator(Optional.of(10_000_000L));
+    assertThat(gasLimitCalculator.apply(8_000_000L))
+        .isEqualTo(8_000_000L + GasLimitCalculator.ADJUSTMENT_FACTOR);
+  }
+
+  @Test
+  public void verifyGasLimitIsDecreasedWithinLimits() {
+    Function<Long, Long> gasLimitCalculator = new GasLimitCalculator(Optional.of(10_000_000L));
+    assertThat(gasLimitCalculator.apply(12_000_000L))
+        .isEqualTo(12_000_000L - GasLimitCalculator.ADJUSTMENT_FACTOR);
+  }
+
+  @Test
+  public void verifyGasLimitReachesTarget() {
+    final long target = 10_000_000L;
+    final long offset = GasLimitCalculator.ADJUSTMENT_FACTOR / 2;
+    Function<Long, Long> gasLimitCalculator = new GasLimitCalculator(Optional.of(target));
+    assertThat(gasLimitCalculator.apply(target - offset)).isEqualTo(target);
+    assertThat(gasLimitCalculator.apply(target + offset)).isEqualTo(target);
+  }
+
+  @Test
+  public void verifyNoNegative() {
+    final long target = 0L;
+    final long offset = GasLimitCalculator.ADJUSTMENT_FACTOR / 2;
+    Function<Long, Long> gasLimitCalculator = new GasLimitCalculator(Optional.of(target));
+    assertThat(gasLimitCalculator.apply(target + offset)).isEqualTo(target);
+  }
+
+  @Test
+  public void verifyNoOverflow() {
+    final long target = Long.MAX_VALUE;
+    final long offset = GasLimitCalculator.ADJUSTMENT_FACTOR / 2;
+    Function<Long, Long> gasLimitCalculator = new GasLimitCalculator(Optional.of(target));
+    assertThat(gasLimitCalculator.apply(target - offset)).isEqualTo(target);
+  }
+}