[tstate] change map[key] from string to fixed size byte array

[hexfusion]

This is an experimentation with replacing the current internal maps from map[string][]byte to map[[65]byte][]byte. In benchmarks I found that using a byte array was much faster than using string as a key. I chose the length based on the largest keys I saw used by transfervm for warp. As you can see by the profiles this cut out a fairly expensive overhead of mappassign_faststr.

ref. https://gitlab.com/pthevenet/go-small-answers/-/blob/29c03407006a269f8f6ba27fa3123fb9742ddf7c/byte-slice-indexed-maps/benchmark_test.go

This reduces the allocations for FetchAndSetScope and provides much cleaner profile (will upload files soon).

goos: linux
goarch: amd64
pkg: github.com/ava-labs/hypersdk/tstate
cpu: Intel(R) Core(TM) i7-10750H CPU @ 2.60GHz
BenchmarkFetchAndSetScope/fetch_and_set_scope_10_keys-12                  239923              4242 ns/op            2402 B/op          3 allocs/op
BenchmarkFetchAndSetScope/fetch_and_set_scope_100_keys-12                  35722             37077 ns/op           27892 B/op         10 allocs/op
BenchmarkFetchAndSetScope/fetch_and_set_scope_1000_keys-12                  2472            572810 ns/op          432668 B/op         26 allocs/op
ok  	github.com/ava-labs/hypersdk/tstate	4.474s

before

after

[patrick-ogrady]

Could you change the 65 here to be a config passed in on init? We should then apply a min filter based on what the HyperSDK stores behind the scenes.

The string conversion I was doing definitely was not optimal...this is probably the right approach.

[patrick-ogrady]

You should make a similar change here:

hypersdk/chain/processor.go

Lines 44 to 79 in a61157d

	func (p *Processor) Prefetch(ctx context.Context, db Database) {
	ctx, span := p.tracer.Start(ctx, "Processor.Prefetch")
	p.db = db
	sm := p.blk.vm.StateManager()
	go func() {
	defer span.End()
	// Store required keys for each set
	alreadyFetched := make(map[string]*fetchData, len(p.blk.GetTxs()))
	for _, tx := range p.blk.GetTxs() {
	storage := map[string][]byte{}
	for _, k := range tx.StateKeys(sm) {
	sk := string(k)
	if v, ok := alreadyFetched[sk]; ok {
	if v.exists {
	storage[sk] = v.v
	}
	continue
	}
	v, err := db.GetValue(ctx, k)
	if errors.Is(err, database.ErrNotFound) {
	alreadyFetched[sk] = &fetchData{nil, false}
	continue
	} else if err != nil {
	panic(err)
	}
	alreadyFetched[sk] = &fetchData{v, true}
	storage[sk] = v
	}
	p.readyTxs <- &txData{tx, storage}
	}
	// Let caller know all sets have been readied
	close(p.readyTxs)
	}()
	}

[patrick-ogrady]

I wonder if the best middle-ground is just to use the approach in BenchmarkOptimizedStringKeyed?

https://pthevenet.com/posts/programming/go/bytesliceindexedmaps/

We then get most of the benefit while retaining flexibility 🤷 .

[hexfusion]

yeah the flexibility loss isn't worth the gain, working on benchmark a few alternatives including yours, hope to have that soon.

[github-actions]

This PR has become stale because it has been open for 30 days with no activity. Adding the lifecycle/frozen label will exempt this PR from future lifecycle events..