Convert slice to array pointer vs copy

Signed-off-by: Sam Batschelet <[email protected]>

Author: hexfusion

chain/processor.go

@@ -20,7 +20,7 @@ type fetchData struct {
 
 type txData struct {
 	tx      *Transaction
-	storage map[tstate.Key][]byte
+	storage map[*tstate.Key][]byte
 }
 
 type Processor struct {
@@ -49,9 +49,9 @@ func (p *Processor) Prefetch(ctx context.Context, db Database) {
 		defer span.End()
 
 		// Store required keys for each set
-		alreadyFetched := make(map[tstate.Key]*fetchData, len(p.blk.GetTxs()))
+		alreadyFetched := make(map[*tstate.Key]*fetchData, len(p.blk.GetTxs()))
 		for _, tx := range p.blk.GetTxs() {
-			storage := map[tstate.Key][]byte{}
+			storage := map[*tstate.Key][]byte{}
 			for _, k := range tx.StateKeys(sm) {
 				sk := tstate.ToStateKeyArray(k)
 				if v, ok := alreadyFetched[sk]; ok {

tstate/tstate.go

@@ -16,7 +16,7 @@ import (
 )
 
 type op struct {
-	k Key
+	k *Key
 
 	pastExists  bool
 	pastV       []byte
@@ -39,14 +39,14 @@ type Key [MapKeyLength]byte
 
 // TState defines a struct for storing temporary state.
 type TState struct {
-	changedKeys map[Key]*tempStorage
-	fetchCache  map[Key]*cacheItem // in case we evict and want to re-fetch
+	changedKeys map[*Key]*tempStorage
+	fetchCache  map[*Key]*cacheItem // in case we evict and want to re-fetch
 
 	// We don't differentiate between read and write scope because it is very
 	// uncommon for a user to write something without first reading what is
 	// there.
 	scope        [][]byte // stores a list of managed keys in the TState struct
-	scopeStorage map[Key][]byte
+	scopeStorage map[*Key][]byte
 
 	// Ops is a record of all operations performed on [TState]. Tracking
 	// operations allows for reverting state to a certain point-in-time.
@@ -57,9 +57,9 @@ type TState struct {
 // maps to have an initial size of [storageSize] and [changedSize] respectively.
 func New(changedSize int) *TState {
 	return &TState{
-		changedKeys: make(map[Key]*tempStorage, changedSize),
+		changedKeys: make(map[*Key]*tempStorage, changedSize),
 
-		fetchCache: map[Key]*cacheItem{},
+		fetchCache: map[*Key]*cacheItem{},
 
 		ops: make([]*op, 0, changedSize),
 	}
@@ -79,7 +79,7 @@ func (ts *TState) GetValue(ctx context.Context, key []byte) ([]byte, error) {
 	return v, nil
 }
 
-func (ts *TState) getValue(_ context.Context, key Key) ([]byte, bool, bool) {
+func (ts *TState) getValue(_ context.Context, key *Key) ([]byte, bool, bool) {
 	if v, ok := ts.changedKeys[key]; ok {
 		if v.removed {
 			return nil, true, false
@@ -97,7 +97,7 @@ func (ts *TState) getValue(_ context.Context, key Key) ([]byte, bool, bool) {
 // FetchAndSetScope then sets the scope of ts to [keys]. If a key exists in
 // ts.fetchCache set the key's value to the value from cache.
 func (ts *TState) FetchAndSetScope(ctx context.Context, keys [][]byte, db Database) error {
-	ts.scopeStorage = map[Key][]byte{}
+	ts.scopeStorage = map[*Key][]byte{}
 
 	for _, key := range keys {
 		k := ToStateKeyArray(key)
@@ -123,7 +123,7 @@ func (ts *TState) FetchAndSetScope(ctx context.Context, keys [][]byte, db Databa
 }
 
 // SetReadScope sets the readscope of ts to [keys].
-func (ts *TState) SetScope(_ context.Context, keys [][]byte, storage map[Key][]byte) {
+func (ts *TState) SetScope(_ context.Context, keys [][]byte, storage map[*Key][]byte) {
 	ts.scope = keys
 	ts.scopeStorage = storage
 }
@@ -221,22 +221,21 @@ func (ts *TState) WriteChanges(
 	defer span.End()
 
 	for key, tstorage := range ts.changedKeys {
+		k := key[:]
 		if !tstorage.removed {
-			if err := db.Insert(ctx, key[:], tstorage.v); err != nil {
+			if err := db.Insert(ctx, k, tstorage.v); err != nil {
 				return err
 			}
 			continue
 		}
-		if err := db.Remove(ctx, key[:]); err != nil {
+		if err := db.Remove(ctx, k); err != nil {
 			return err
 		}
 	}
 	return nil
 }
 
 // ToStateKeyArray converts a byte slice to byte array.
-func ToStateKeyArray(key []byte) Key {
-	var k Key
-	copy(k[:], key)
-	return k
+func ToStateKeyArray(key []byte) *Key {
+	return (*Key)(key)
 }