Beedle - Oracle free perpetual lending

Summary The statement that state variables should be cached in stack variables rather than re-reading them from storage is not accurate. In Solidity, state variables are already stored in storage, and accessing them directly from storage is generally more efficient in terms of gas cost.

When you access a state variable in a function, the value is typically read directly from storage and cached in memory for the duration of the function execution. This caching mechanism helps reduce the number of expensive SLOAD (storage load) operations, which incur higher gas costs.

On the other hand, if you were to cache a state variable in a stack variable, you would need to manually load the value from storage into the stack variable. This additional step of loading the value into memory could result in higher gas costs compared to directly accessing the state variable from storage.

Here's an example to illustrate this:

contract MyContract {
uint256 public myVariable;

function readFromStorage() external view returns (uint256) {
    return myVariable;  // Directly accessing state variable from storage
}

function cacheInStackVariable() external view returns (uint256) {
    uint256 cachedValue = myVariable;  // Caching state variable in stack variable
    return cachedValue;
}

}

In the readFromStorage() function, the state variable myVariable is accessed directly from storage, resulting in a more gas-efficient operation.
In the cacheInStackVariable() function, the state variable is first loaded into a stack variable cachedValue before being returned. This additional step of loading the value into memory could potentially increase the gas cost.
It's important to note that Solidity already optimizes the access to state variables, and the compiler makes use of internal caching mechanisms. This means that manually caching state variables in stack variables is generally unnecessary and can potentially lead to redundant code that incurs additional gas costs.

In summary, accessing state variables directly from storage is typically more gas-efficient due to the built-in optimizations provided by Solidity. Manually caching state variables in stack variables is not necessary and can potentially increase gas consumption without providing any notable benefits.