💰Gas Saving Technique 4: Cache Array Length

Book an audit with Zokyo

Introduction

Efficiently managing gas consumption is pivotal when developing smart contracts. A subtle, yet effective technique to conserve gas during loop operations involves caching the length of arrays. This practice significantly reduces the number of read operations from the contract's storage, each of which would otherwise consume gas on every loop iteration.

Vulnerability Details & Impact

Understanding Gas Consumption

Reading from storage in Ethereum is expensive in terms of gas. When iterating through arrays using a for-loop without caching the array length, the length is read from storage during every iteration, incurring extra gas costs for each read operation. Specifically, reading the array's length at each iteration costs around 6 gas units (3 for mload and 3 to place memory_offset in the stack).

Gas Savings Through Reduction in Reads

Caching the array length in a variable prior to the loop's execution minimizes the number of read operations, thereby saving approximately 3 gas units per iteration. This can lead to significant gas savings, especially in scenarios where loops run through large arrays.

How to Implement Caching for Gas Savings

Practical Example: Caching Array Length to Reduce Reads

Let’s look at an example to better understand this:

Before Optimization:

solidityCopy code// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract LoopGasOptimizer {
    uint[] public values;

    function calculateSum() public view returns (uint) {
        uint sum = 0;
        for (uint i = 0; i < values.length; i++) {
            sum += values[i];  // The length is read from storage on every iteration
        }
        return sum;
    }
}

After Optimization:

solidityCopy code// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract LoopGasOptimizer {
    uint[] public values;

    function calculateSum() public view returns (uint) {
        uint sum = 0;
        uint length = values.length;  // Cache the array length to reduce reads
        for (uint i = 0; i < length; i++) {
            sum += values[i];
        }
        return sum;
    }
}

In the optimized version, the number of read operations from storage is reduced by caching values.length into a variable, thereby saving gas on every loop iteration.

Recommended Mitigation Steps

1. Identify Loops: Go through your smart contracts to find for-loops iterating over arrays.

2. Cache Array Length: Cache the array length in a local variable before the loop commences.

3. Use the Cached Length: Refer to the cached length variable in the loop condition, thus minimizing the number of storage read operations and saving gas.

Conclusion

While it might seem trivial, caching array lengths in loops is a valuable practice for reducing the number of read operations from storage, leading to gas savings. This practice is particularly crucial for contracts that deal with large arrays and frequent loop operations. Implementing this technique, combined with diligent testing, ensures your smart contracts are both efficient and functionally robust.