Optimization: Eliminate double-read when manipulating Option on storage

[cmichi]

When loading an object from storage we have an overhead of one read operation.

See here:

    // In case the contract storage is occupied we handle
    // the Option<T> as if it was a T.
    ink_env::get_contract_storage::<()>(root_key)
        .ok()
        .flatten()
        .map(|_| super::pull_spread_root::<T>(root_key))

We read the root_key two times from storage.

At the moment there is no API to ask Seal if a storage is occupied, so instead we have to issue the first read in order to find out if it's None or Some(…). In the latter case we pull recursively from storage.

Possible Solution

We probably have to adapt the SpreadLayout interface, since we have to cache those reads ourselves. An option could be to implement caching into KeyPtr.

[Robbepop]

The special challenge behind this is to find a solution that optimally works without using heap memory allocation so that simpler contracts can still get rid of the heap allocator. This is very important since this machinery is very deeply rooted in all ink! smart contracts.
We are not without weapons here since we can make use of the ScopeBuffer internals of our ink_env on-chain environment. For off-chain we do not care about heap allocations whatsoever.

[cmichi]

I've removed this ticket from Substrate's "Improve throughput" issue, since this issue here rather targets the runtime performance by having one storage read less. The "Improve throughput" issue on the other hand aims to reduce the size of contracts. The ideas we've had so far to solve this very issue here involve more code (i.e. caching) though.