Cached state values in the program state

[iFrostizz]

Closes #722

Add a cache to the program state in order to be able to return values that were previously written / read instead of always getting it from the runtime to benefit from a performance boost.

[richardpringle]

Nothing major

[richardpringle]

👍

[richardpringle]

Did you try using the HashMap::entry method? It should enable you do get val_bytes without cloning anywhere.

[iFrostizz]

I did tried, but the entry API doesn't provide any convenient method other than chaining and_modify with or_insert, moreover the value of the HashMap is owned so I'm not sure if we can get around that.

[iFrostizz]

By permutating the line that calls from_slice with the one that inserts in the map, I could get around that clone.

[richardpringle]

Not sure what you mean by "permutating".

I think it should look something more like this:

    pub fn get<V>(&mut self, key: K) -> Result<Option<V>, Error>
    where
        V: BorshDeserialize,
    {
        if let Some(val) = self.cache.get(&key) {
            return from_slice(&val)
                .map_err(|_| Error::Deserialization)
                .map(Some);
        }

        let host_ptr = unsafe {
            // cloning the key here isn't ideal, but we should be able to fix this later
            host::get_bytes(&self.program, &key.clone().into()).map_err(|_| Error::Read)?
        };

        // I'm not 100% that this is how the host handles things when a key doesn't exist
        if host_ptr == 0 {
            return Ok(None);
        }

        let bytes = into_bytes(host_ptr);
        let val = self.cache.entry(key).or_insert(bytes);

        from_slice(&val)
            .map_err(|_| Error::Deserialization)
            .map(Some)
    }

[richardpringle]

Actually, this might be better:

    pub fn get<V>(&mut self, key: K) -> Result<Option<V>, Error>
    where
        V: BorshDeserialize,
    {
        let val = if let Some(val) = self.cache.get(&key) {
            val
        } else {
            let host_ptr = unsafe {
                host::get_bytes(&self.program, &key.clone().into()).map_err(|_| Error::Read)?
            };

            if host_ptr == 0 {
                return Ok(None);
            }

            let bytes = into_bytes(host_ptr);
            self.cache.entry(key).or_insert(bytes)
        };

        from_slice(val)
            .map_err(|_| Error::Deserialization)
            .map(Some)
    }

[richardpringle]

🤔... looks like there's a failure somewhere.