mirror of
https://github.com/ethereum/go-ethereum.git
synced 2026-02-26 15:47:21 +00:00
3bbf5f5b6a
Looks like (in some very EVM specific tests) we spent a lot of time
resizing memory. If the underlying array is big enough, we can speed it
up a bit by simply slicing the memory.
goos: linux
goarch: amd64
pkg: github.com/ethereum/go-ethereum/core/vm
cpu: Intel(R) Core(TM) Ultra 7 155U
│ /tmp/old.txt │ /tmp/new.txt │
│ sec/op │ sec/op vs base │
Resize-14 6.145n ± 9% 1.854n ± 14% -69.83% (p=0.000 n=10)
│ /tmp/old.txt │ /tmp/new.txt │
│ B/op │ B/op vs base │
Resize-14 5.000 ± 0% 5.000 ± 0% ~ (p=1.000 n=10)
│ /tmp/old.txt │ /tmp/new.txt │
│ allocs/op │ allocs/op vs base │
Resize-14 0.000 ± 0% 0.000 ± 0% ~ (p=1.000 n=10) ¹
From the blocktest benchmark:
620ms 10.93s (flat, cum) 9.92% of Total
. . 80:func (m *Memory) Resize(size uint64) {
30ms 60ms 81: if uint64(m.Len()) < size {
590ms 10.87s 82: m.store = append(m.store, make([]byte, size-uint64(m.Len()))...)
. . 83: }
. . 84:}
---------
Co-authored-by: Felix Lange <fjl@twurst.com>
92 lines
3.1 KiB
Go
92 lines
3.1 KiB
Go
// Copyright 2023 The go-ethereum Authors
|
|
// This file is part of the go-ethereum library.
|
|
//
|
|
// The go-ethereum library is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU Lesser General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// The go-ethereum library is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU Lesser General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Lesser General Public License
|
|
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
package vm
|
|
|
|
import (
|
|
"bytes"
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/ethereum/go-ethereum/common"
|
|
)
|
|
|
|
func TestMemoryCopy(t *testing.T) {
|
|
// Test cases from https://eips.ethereum.org/EIPS/eip-5656#test-cases
|
|
for i, tc := range []struct {
|
|
dst, src, len uint64
|
|
pre string
|
|
want string
|
|
}{
|
|
{ // MCOPY 0 32 32 - copy 32 bytes from offset 32 to offset 0.
|
|
0, 32, 32,
|
|
"0000000000000000000000000000000000000000000000000000000000000000 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f",
|
|
"000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f",
|
|
},
|
|
|
|
{ // MCOPY 0 0 32 - copy 32 bytes from offset 0 to offset 0.
|
|
0, 0, 32,
|
|
"0101010101010101010101010101010101010101010101010101010101010101",
|
|
"0101010101010101010101010101010101010101010101010101010101010101",
|
|
},
|
|
{ // MCOPY 0 1 8 - copy 8 bytes from offset 1 to offset 0 (overlapping).
|
|
0, 1, 8,
|
|
"000102030405060708 000000000000000000000000000000000000000000000000",
|
|
"010203040506070808 000000000000000000000000000000000000000000000000",
|
|
},
|
|
{ // MCOPY 1 0 8 - copy 8 bytes from offset 0 to offset 1 (overlapping).
|
|
1, 0, 8,
|
|
"000102030405060708 000000000000000000000000000000000000000000000000",
|
|
"000001020304050607 000000000000000000000000000000000000000000000000",
|
|
},
|
|
// Tests below are not in the EIP, but maybe should be added
|
|
{ // MCOPY 0xFFFFFFFFFFFF 0xFFFFFFFFFFFF 0 - copy zero bytes from out-of-bounds index(overlapping).
|
|
0xFFFFFFFFFFFF, 0xFFFFFFFFFFFF, 0,
|
|
"11",
|
|
"11",
|
|
},
|
|
{ // MCOPY 0xFFFFFFFFFFFF 0 0 - copy zero bytes from start of mem to out-of-bounds.
|
|
0xFFFFFFFFFFFF, 0, 0,
|
|
"11",
|
|
"11",
|
|
},
|
|
{ // MCOPY 0 0xFFFFFFFFFFFF 0 - copy zero bytes from out-of-bounds to start of mem
|
|
0, 0xFFFFFFFFFFFF, 0,
|
|
"11",
|
|
"11",
|
|
},
|
|
} {
|
|
m := NewMemory()
|
|
// Clean spaces
|
|
data := common.FromHex(strings.ReplaceAll(tc.pre, " ", ""))
|
|
// Set pre
|
|
m.Resize(uint64(len(data)))
|
|
m.Set(0, uint64(len(data)), data)
|
|
// Do the copy
|
|
m.Copy(tc.dst, tc.src, tc.len)
|
|
want := common.FromHex(strings.ReplaceAll(tc.want, " ", ""))
|
|
if have := m.store; !bytes.Equal(want, have) {
|
|
t.Errorf("case %d: want: %#x\nhave: %#x\n", i, want, have)
|
|
}
|
|
}
|
|
}
|
|
|
|
func BenchmarkResize(b *testing.B) {
|
|
memory := NewMemory()
|
|
for i := range b.N {
|
|
memory.Resize(uint64(i))
|
|
}
|
|
}
|