core,codetrie: generalize contract logic to multiple chunk sizes

Author: s1na

codetrie/contract.go

@@ -10,20 +10,21 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 )
 
-const CHUNK_SIZE = 32
+var CHUNK_SIZES = [...]int{24, 32, 40}
 
 type CMStats struct {
 	NumContracts int
-	ProofSize    int
+	ProofSizes   []int
 	CodeSize     int
-	ProofStats   *ssz.ProofStats
-	RLPStats     *ssz.RLPStats
+	ProofStats   []*ssz.ProofStats
+	RLPStats     []*ssz.RLPStats
 }
 
 func NewCMStats() *CMStats {
 	return &CMStats{
-		ProofStats: &ssz.ProofStats{},
-		RLPStats:   &ssz.RLPStats{},
+		ProofSizes: make([]int, len(CHUNK_SIZES)),
+		ProofStats: make([]*ssz.ProofStats, len(CHUNK_SIZES)),
+		RLPStats:   make([]*ssz.RLPStats, len(CHUNK_SIZES)),
 	}
 }
 
@@ -59,33 +60,40 @@ func (b *ContractBag) Stats() (*CMStats, error) {
 	stats.NumContracts = len(b.contracts)
 	for _, c := range b.contracts {
 		stats.CodeSize += c.CodeSize()
-		rawProof, err := c.Prove()
+		rawProofs, err := c.Prove()
 		if err != nil {
 			return nil, err
 		}
-		p := ssz.NewMultiproof(rawProof)
-		cp := ssz.NewCompressedMultiproof(rawProof.Compress())
-
-		ps := cp.ProofStats()
-		stats.ProofStats.Add(ps)
-
-		rs, err := ssz.NewRLPStats(p, cp)
-		if err != nil {
-			return nil, err
+		for i, rawProof := range rawProofs {
+			p := ssz.NewMultiproof(rawProof)
+			cp := ssz.NewCompressedMultiproof(rawProof.Compress())
+
+			ps := cp.ProofStats()
+			stats.ProofStats[i].Add(ps)
+
+			rs, err := ssz.NewRLPStats(p, cp)
+			if err != nil {
+				return nil, err
+			}
+			stats.RLPStats[i].Add(rs)
 		}
-		stats.RLPStats.Add(rs)
 	}
-	stats.ProofSize = stats.ProofStats.Sum()
+	for i := 0; i < len(stats.ProofSizes); i++ {
+		stats.ProofSizes[i] = stats.ProofStats[i].Sum()
+	}
 	return stats, nil
 }
 
 type Contract struct {
 	code          []byte
-	touchedChunks map[int]bool
+	touchedChunks []map[int]bool
 }
 
 func NewContract(code []byte) *Contract {
-	touchedChunks := make(map[int]bool)
+	touchedChunks := make([]map[int]bool, len(CHUNK_SIZES))
+	for i := 0; i < len(touchedChunks); i++ {
+		touchedChunks[i] = make(map[int]bool)
+	}
 	return &Contract{code: code, touchedChunks: touchedChunks}
 }
 
@@ -94,8 +102,10 @@ func (c *Contract) TouchPC(pc int) error {
 		return errors.New("PC to touch exceeds bytecode length")
 	}
 
-	cid := pc / CHUNK_SIZE
-	c.touchedChunks[cid] = true
+	for i, s := range CHUNK_SIZES {
+		cid := pc / s
+		c.touchedChunks[i][cid] = true
+	}
 
 	return nil
 }
@@ -108,10 +118,12 @@ func (c *Contract) TouchRange(from, to int) error {
 		return errors.New("PC to touch exceeds bytecode length")
 	}
 
-	fcid := from / CHUNK_SIZE
-	tcid := to / CHUNK_SIZE
-	for i := fcid; i < tcid+1; i++ {
-		c.touchedChunks[i] = true
+	for i, s := range CHUNK_SIZES {
+		fcid := from / s
+		tcid := to / s
+		for j := fcid; j < tcid+1; j++ {
+			c.touchedChunks[i][j] = true
+		}
 	}
 
 	return nil
@@ -121,36 +133,41 @@ func (c *Contract) CodeSize() int {
 	return len(c.code)
 }
 
-func (c *Contract) Prove() (*sszlib.Multiproof, error) {
-	tree, err := GetSSZTree(c.code, CHUNK_SIZE)
-	if err != nil {
-		return nil, err
-	}
+func (c *Contract) Prove() ([]*sszlib.Multiproof, error) {
+	proofs := make([]*sszlib.Multiproof, len(CHUNK_SIZES))
+	for i, s := range CHUNK_SIZES {
+		tree, err := GetSSZTree(c.code, uint(s))
+		if err != nil {
+			return nil, err
+		}
 
-	// ChunksLen and metadata fields
-	mdIndices := []int{7, 8, 9, 10}
-
-	touchedChunks := c.sortedTouchedChunks()
-	chunkIndices := make([]int, 0, len(touchedChunks)*2)
-	for k := range touchedChunks {
-		// 6144 is global index for first chunk's node
-		// Each chunk node has two children: FIO, code
-		chunkIdx := 6144 + k
-		chunkIndices = append(chunkIndices, chunkIdx*2)
-		chunkIndices = append(chunkIndices, chunkIdx*2+1)
-	}
+		// ChunksLen and metadata fields
+		mdIndices := []int{7, 8, 9, 10}
+
+		touchedChunks := c.sortedTouchedChunks(i)
+		chunkIndices := make([]int, 0, len(touchedChunks)*2)
+		for k := range touchedChunks {
+			// 6144 is global index for first chunk's node
+			// Each chunk node has two children: FIO, code
+			chunkIdx := 6144 + k
+			chunkIndices = append(chunkIndices, chunkIdx*2)
+			chunkIndices = append(chunkIndices, chunkIdx*2+1)
+		}
+
+		p, err := tree.ProveMulti(append(mdIndices, chunkIndices...))
+		if err != nil {
+			return nil, err
+		}
 
-	p, err := tree.ProveMulti(append(mdIndices, chunkIndices...))
-	if err != nil {
-		return nil, err
+		proofs[i] = p
 	}
 
-	return p, nil
+	return proofs, nil
 }
 
-func (c *Contract) sortedTouchedChunks() []int {
-	touched := make([]int, 0, len(c.touchedChunks))
-	for k := range c.touchedChunks {
+func (c *Contract) sortedTouchedChunks(sizeIndex int) []int {
+	touched := make([]int, 0, len(c.touchedChunks[sizeIndex]))
+	for k := range c.touchedChunks[sizeIndex] {
 		touched = append(touched, k)
 	}
 	sort.Ints(touched)

core/state_processor.go

@@ -98,7 +98,9 @@ func (p *StateProcessor) Process(block *types.Block, statedb *state.StateDB, cfg
 
 		defer cmFile.Close()
 		if stats.NumContracts > 0 {
-			if _, err := cmFile.WriteString(fmt.Sprintf("%d, %d, %d, %d, %d, %d, %d, %d, %d, %d\n", block.NumberU64(), stats.CodeSize, stats.ProofSize, stats.RLPStats.RLPSize, stats.RLPStats.UnRLPSize, stats.RLPStats.SnappySize, stats.ProofStats.Indices, stats.ProofStats.ZeroLevels, stats.ProofStats.Hashes, stats.ProofStats.Leaves)); err != nil {
+			rlpStats := stats.RLPStats[1]
+			proofStats := stats.ProofStats[1]
+			if _, err := cmFile.WriteString(fmt.Sprintf("%d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d\n", block.NumberU64(), stats.CodeSize, stats.ProofSizes[0], stats.ProofSizes[1], stats.ProofSizes[2], rlpStats.RLPSize, rlpStats.UnRLPSize, rlpStats.SnappySize, proofStats.Indices, proofStats.ZeroLevels, proofStats.Hashes, proofStats.Leaves)); err != nil {
 				return nil, nil, 0, err
 			}
 		}