From c012f08c66b3d906904c956477563f4d2117bdbd Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Daniel=20Mart=C3=AD?= Date: Sun, 1 Dec 2024 00:22:18 +0000 Subject: [PATCH] store name pairs for _realName as a slice of pairs MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Iterating over a map is much more expensive than iterating over a slice, given how it needs to work out which keys are present in each bucket and then randomize the order in which to navigate the keys. None of this work needs to happen when iterating over a slice. A map would be nice if we were to actually do map lookups, but we don't. │ old │ new │ │ sec/op │ sec/op vs base │ AbiRealName-8 707.1µ ± 1% 196.7µ ± 1% -72.17% (p=0.001 n=7) │ old │ new │ │ B/s │ B/s vs base │ AbiRealName-8 517.6Ki ± 2% 1816.4Ki ± 1% +250.94% (p=0.001 n=7) │ old │ new │ │ B/op │ B/op vs base │ AbiRealName-8 5.362Ki ± 0% 5.359Ki ± 0% -0.05% (p=0.001 n=7) │ old │ new │ │ allocs/op │ allocs/op vs base │ AbiRealName-8 19.00 ± 0% 19.00 ± 0% ~ (p=1.000 n=7) ¹ --- bench_test.go | 23 ++++++++++++++++------- reflect_abi_code.go | 6 ++++-- reflect_abi_patch.go | 6 +++--- 3 files changed, 23 insertions(+), 12 deletions(-) diff --git a/bench_test.go b/bench_test.go index 7e5f770..83ae9b4 100644 --- a/bench_test.go +++ b/bench_test.go @@ -7,12 +7,11 @@ import ( _ "embed" "flag" "fmt" - "maps" + "math/rand/v2" "os" "os/exec" "path/filepath" "regexp" - "slices" "strconv" "strings" "testing" @@ -170,18 +169,28 @@ func BenchmarkBuild(b *testing.B) { } func BenchmarkAbiRealName(b *testing.B) { - // Benchmark two thousand obfuscated names in _nameMap + // Benchmark two thousand obfuscated names in _realNamePairs // and a variety of input strings to reverse. // As an example, the cmd/go binary ends up with about 2200 entries - // in _nameMap as of November 2024, so it's a realistic figure. + // in _realNamePairs as of November 2024, so it's a realistic figure. // Structs with tens of fields are also relatively normal. salt := []byte("some salt bytes") for n := range 2000 { name := fmt.Sprintf("name_%d", n) garbled := hashWithCustomSalt(salt, name) - _nameMap[garbled] = name + _realNamePairs = append(_realNamePairs, [2]string{garbled, name}) } - chosen := slices.Sorted(maps.Keys(_nameMap))[:20] + // Pick twenty names at random to use as inputs below. + // Use a deterministic random source so it's stable between benchmark runs. + rnd := rand.New(rand.NewPCG(1, 2)) + var chosen []string + for _, pair := range _realNamePairs { + chosen = append(chosen, pair[0]) + } + rnd.Shuffle(len(chosen), func(i, j int) { + chosen[i], chosen[j] = chosen[j], chosen[i] + }) + chosen = chosen[:20] inputs := []string{ // non-obfuscated names and types @@ -214,5 +223,5 @@ func BenchmarkAbiRealName(b *testing.B) { } } }) - _nameMap = map[string]string{} + _realNamePairs = [][2]string{} } diff --git a/reflect_abi_code.go b/reflect_abi_code.go index dab25ec..ce90d8d 100644 --- a/reflect_abi_code.go +++ b/reflect_abi_code.go @@ -39,7 +39,9 @@ func _realName(name string) string { } remLen := len(name[i:]) found := false - for obfName, real := range _nameMap { + for _, pair := range _realNamePairs { + obfName := pair[0] + real := pair[1] keyLen := len(obfName) if remLen < keyLen { continue @@ -58,4 +60,4 @@ func _realName(name string) string { return name } -var _nameMap = map[string]string{} +var _realNamePairs = [][2]string{} diff --git a/reflect_abi_patch.go b/reflect_abi_patch.go index 0856547..731b47b 100644 --- a/reflect_abi_patch.go +++ b/reflect_abi_patch.go @@ -58,13 +58,13 @@ func reflectMainPrePatch(path string) ([]byte, error) { // reflectMainPostPatch populates the name mapping with the final obfuscated->real name // mappings after all packages have been analyzed. func reflectMainPostPatch(file []byte, lpkg *listedPackage, pkg pkgCache) []byte { - obfMapName := hashWithPackage(lpkg, "_nameMap") - nameMap := fmt.Sprintf("%s = map[string]string{", obfMapName) + obfVarName := hashWithPackage(lpkg, "_realNamePairs") + nameMap := fmt.Sprintf("%s = [][2]string{", obfVarName) var b strings.Builder keys := slices.Sorted(maps.Keys(pkg.ReflectObjectNames)) for _, obf := range keys { - b.WriteString(fmt.Sprintf(`"%s": "%s",`, obf, pkg.ReflectObjectNames[obf])) + b.WriteString(fmt.Sprintf("{%q, %q},", obf, pkg.ReflectObjectNames[obf])) } return bytes.Replace(file, []byte(nameMap), []byte(nameMap+b.String()), 1)