2020-06-30 02:36:45 +00:00
|
|
|
// Copyright (c) 2020 Tailscale Inc & AUTHORS All rights reserved.
|
|
|
|
// Use of this source code is governed by a BSD-style
|
|
|
|
// license that can be found in the LICENSE file.
|
|
|
|
|
2021-05-11 19:09:25 +00:00
|
|
|
package deephash
|
2020-06-28 17:58:21 +00:00
|
|
|
|
|
|
|
import (
|
2021-07-21 17:26:04 +00:00
|
|
|
"archive/tar"
|
2021-08-30 17:47:21 +00:00
|
|
|
"crypto/sha256"
|
2021-05-11 20:17:12 +00:00
|
|
|
"fmt"
|
2022-08-12 00:44:09 +00:00
|
|
|
"hash"
|
2022-06-25 19:46:01 +00:00
|
|
|
"io"
|
2021-08-03 04:44:13 +00:00
|
|
|
"math"
|
2022-06-16 20:21:32 +00:00
|
|
|
"math/rand"
|
2022-07-26 03:55:44 +00:00
|
|
|
"net/netip"
|
2021-05-11 20:17:12 +00:00
|
|
|
"reflect"
|
2021-08-30 17:47:21 +00:00
|
|
|
"runtime"
|
2020-06-28 17:58:21 +00:00
|
|
|
"testing"
|
2022-06-16 20:21:32 +00:00
|
|
|
"testing/quick"
|
2022-06-15 05:49:11 +00:00
|
|
|
"time"
|
|
|
|
"unsafe"
|
2020-06-28 17:58:21 +00:00
|
|
|
|
2021-11-02 21:41:56 +00:00
|
|
|
"go4.org/mem"
|
2021-05-11 16:45:12 +00:00
|
|
|
"tailscale.com/tailcfg"
|
2021-08-05 21:05:24 +00:00
|
|
|
"tailscale.com/types/dnstype"
|
2021-07-07 18:58:02 +00:00
|
|
|
"tailscale.com/types/ipproto"
|
2021-10-28 00:42:33 +00:00
|
|
|
"tailscale.com/types/key"
|
2022-06-15 05:49:11 +00:00
|
|
|
"tailscale.com/types/structs"
|
2022-07-27 16:10:22 +00:00
|
|
|
"tailscale.com/util/deephash/testtype"
|
2021-05-11 16:45:12 +00:00
|
|
|
"tailscale.com/util/dnsname"
|
2021-07-07 18:40:28 +00:00
|
|
|
"tailscale.com/version"
|
2021-07-07 18:58:02 +00:00
|
|
|
"tailscale.com/wgengine/filter"
|
2021-03-26 00:41:51 +00:00
|
|
|
"tailscale.com/wgengine/router"
|
2021-01-29 20:16:36 +00:00
|
|
|
"tailscale.com/wgengine/wgcfg"
|
2020-06-28 17:58:21 +00:00
|
|
|
)
|
|
|
|
|
2021-07-21 18:29:08 +00:00
|
|
|
type appendBytes []byte
|
|
|
|
|
|
|
|
func (p appendBytes) AppendTo(b []byte) []byte {
|
|
|
|
return append(b, p...)
|
|
|
|
}
|
|
|
|
|
2021-07-21 17:26:04 +00:00
|
|
|
func TestHash(t *testing.T) {
|
2022-03-16 23:27:57 +00:00
|
|
|
type tuple [2]any
|
|
|
|
type iface struct{ X any }
|
2021-08-03 04:44:13 +00:00
|
|
|
type scalars struct {
|
|
|
|
I8 int8
|
|
|
|
I16 int16
|
|
|
|
I32 int32
|
|
|
|
I64 int64
|
|
|
|
I int
|
|
|
|
U8 uint8
|
|
|
|
U16 uint16
|
|
|
|
U32 uint32
|
|
|
|
U64 uint64
|
|
|
|
U uint
|
|
|
|
UP uintptr
|
|
|
|
F32 float32
|
|
|
|
F64 float64
|
|
|
|
C64 complex64
|
|
|
|
C128 complex128
|
|
|
|
}
|
2021-07-21 17:26:04 +00:00
|
|
|
type MyBool bool
|
|
|
|
type MyHeader tar.Header
|
2022-06-22 02:50:48 +00:00
|
|
|
var zeroFloat64 float64
|
2021-07-21 17:26:04 +00:00
|
|
|
tests := []struct {
|
|
|
|
in tuple
|
|
|
|
wantEq bool
|
|
|
|
}{
|
2021-08-03 04:44:13 +00:00
|
|
|
{in: tuple{false, true}, wantEq: false},
|
|
|
|
{in: tuple{true, true}, wantEq: true},
|
|
|
|
{in: tuple{false, false}, wantEq: true},
|
|
|
|
{
|
|
|
|
in: tuple{
|
|
|
|
scalars{-8, -16, -32, -64, -1234, 8, 16, 32, 64, 1234, 5678, 32.32, 64.64, 32 + 32i, 64 + 64i},
|
|
|
|
scalars{-8, -16, -32, -64, -1234, 8, 16, 32, 64, 1234, 5678, 32.32, 64.64, 32 + 32i, 64 + 64i},
|
|
|
|
},
|
|
|
|
wantEq: true,
|
|
|
|
},
|
|
|
|
{in: tuple{scalars{I8: math.MinInt8}, scalars{I8: math.MinInt8 / 2}}, wantEq: false},
|
|
|
|
{in: tuple{scalars{I16: math.MinInt16}, scalars{I16: math.MinInt16 / 2}}, wantEq: false},
|
|
|
|
{in: tuple{scalars{I32: math.MinInt32}, scalars{I32: math.MinInt32 / 2}}, wantEq: false},
|
|
|
|
{in: tuple{scalars{I64: math.MinInt64}, scalars{I64: math.MinInt64 / 2}}, wantEq: false},
|
|
|
|
{in: tuple{scalars{I: -1234}, scalars{I: -1234 / 2}}, wantEq: false},
|
|
|
|
{in: tuple{scalars{U8: math.MaxUint8}, scalars{U8: math.MaxUint8 / 2}}, wantEq: false},
|
|
|
|
{in: tuple{scalars{U16: math.MaxUint16}, scalars{U16: math.MaxUint16 / 2}}, wantEq: false},
|
|
|
|
{in: tuple{scalars{U32: math.MaxUint32}, scalars{U32: math.MaxUint32 / 2}}, wantEq: false},
|
|
|
|
{in: tuple{scalars{U64: math.MaxUint64}, scalars{U64: math.MaxUint64 / 2}}, wantEq: false},
|
|
|
|
{in: tuple{scalars{U: 1234}, scalars{U: 1234 / 2}}, wantEq: false},
|
|
|
|
{in: tuple{scalars{UP: 5678}, scalars{UP: 5678 / 2}}, wantEq: false},
|
|
|
|
{in: tuple{scalars{F32: 32.32}, scalars{F32: math.Nextafter32(32.32, 0)}}, wantEq: false},
|
|
|
|
{in: tuple{scalars{F64: 64.64}, scalars{F64: math.Nextafter(64.64, 0)}}, wantEq: false},
|
|
|
|
{in: tuple{scalars{F32: float32(math.NaN())}, scalars{F32: float32(math.NaN())}}, wantEq: true},
|
|
|
|
{in: tuple{scalars{F64: float64(math.NaN())}, scalars{F64: float64(math.NaN())}}, wantEq: true},
|
|
|
|
{in: tuple{scalars{C64: 32 + 32i}, scalars{C64: complex(math.Nextafter32(32, 0), 32)}}, wantEq: false},
|
|
|
|
{in: tuple{scalars{C128: 64 + 64i}, scalars{C128: complex(math.Nextafter(64, 0), 64)}}, wantEq: false},
|
2021-07-21 18:29:08 +00:00
|
|
|
{in: tuple{[]appendBytes{{}, {0, 0, 0, 0, 0, 0, 0, 1}}, []appendBytes{{}, {0, 0, 0, 0, 0, 0, 0, 1}}}, wantEq: true},
|
|
|
|
{in: tuple{[]appendBytes{{}, {0, 0, 0, 0, 0, 0, 0, 1}}, []appendBytes{{0, 0, 0, 0, 0, 0, 0, 1}, {}}}, wantEq: false},
|
2021-07-21 17:26:04 +00:00
|
|
|
{in: tuple{iface{MyBool(true)}, iface{MyBool(true)}}, wantEq: true},
|
|
|
|
{in: tuple{iface{true}, iface{MyBool(true)}}, wantEq: false},
|
|
|
|
{in: tuple{iface{MyHeader{}}, iface{MyHeader{}}}, wantEq: true},
|
|
|
|
{in: tuple{iface{MyHeader{}}, iface{tar.Header{}}}, wantEq: false},
|
|
|
|
{in: tuple{iface{&MyHeader{}}, iface{&MyHeader{}}}, wantEq: true},
|
|
|
|
{in: tuple{iface{&MyHeader{}}, iface{&tar.Header{}}}, wantEq: false},
|
|
|
|
{in: tuple{iface{[]map[string]MyBool{}}, iface{[]map[string]MyBool{}}}, wantEq: true},
|
|
|
|
{in: tuple{iface{[]map[string]bool{}}, iface{[]map[string]MyBool{}}}, wantEq: false},
|
2022-06-22 02:50:48 +00:00
|
|
|
{in: tuple{zeroFloat64, -zeroFloat64}, wantEq: false}, // Issue 4883 (false alarm)
|
|
|
|
{in: tuple{[]any(nil), 0.0}, wantEq: false}, // Issue 4883
|
|
|
|
{in: tuple{[]any(nil), uint8(0)}, wantEq: false}, // Issue 4883
|
|
|
|
{in: tuple{nil, nil}, wantEq: true}, // Issue 4883
|
2021-07-22 22:22:48 +00:00
|
|
|
{
|
|
|
|
in: func() tuple {
|
|
|
|
i1 := 1
|
|
|
|
i2 := 2
|
|
|
|
v1 := [3]*int{&i1, &i2, &i1}
|
|
|
|
v2 := [3]*int{&i1, &i2, &i2}
|
|
|
|
return tuple{v1, v2}
|
|
|
|
}(),
|
|
|
|
wantEq: false,
|
|
|
|
},
|
2021-07-21 17:26:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
for _, tt := range tests {
|
|
|
|
gotEq := Hash(tt.in[0]) == Hash(tt.in[1])
|
|
|
|
if gotEq != tt.wantEq {
|
2022-06-22 02:50:48 +00:00
|
|
|
t.Errorf("(Hash(%T %v) == Hash(%T %v)) = %v, want %v", tt.in[0], tt.in[0], tt.in[1], tt.in[1], gotEq, tt.wantEq)
|
2021-07-21 17:26:04 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-05-18 20:16:37 +00:00
|
|
|
func TestDeepHash(t *testing.T) {
|
2020-06-28 17:58:21 +00:00
|
|
|
// v contains the types of values we care about for our current callers.
|
|
|
|
// Mostly we're just testing that we don't panic on handled types.
|
|
|
|
v := getVal()
|
|
|
|
|
2021-07-05 04:25:15 +00:00
|
|
|
hash1 := Hash(v)
|
2020-06-28 17:58:21 +00:00
|
|
|
t.Logf("hash: %v", hash1)
|
|
|
|
for i := 0; i < 20; i++ {
|
2021-07-05 04:25:15 +00:00
|
|
|
hash2 := Hash(getVal())
|
2020-06-28 17:58:21 +00:00
|
|
|
if hash1 != hash2 {
|
|
|
|
t.Error("second hash didn't match")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-06-16 18:24:04 +00:00
|
|
|
// Tests that we actually hash map elements. Whoops.
|
|
|
|
func TestIssue4868(t *testing.T) {
|
|
|
|
m1 := map[int]string{1: "foo"}
|
|
|
|
m2 := map[int]string{1: "bar"}
|
|
|
|
if Hash(m1) == Hash(m2) {
|
|
|
|
t.Error("bogus")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-06-16 20:21:32 +00:00
|
|
|
func TestIssue4871(t *testing.T) {
|
|
|
|
m1 := map[string]string{"": "", "x": "foo"}
|
|
|
|
m2 := map[string]string{}
|
|
|
|
if h1, h2 := Hash(m1), Hash(m2); h1 == h2 {
|
|
|
|
t.Errorf("bogus: h1=%x, h2=%x", h1, h2)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestNilVsEmptymap(t *testing.T) {
|
|
|
|
m1 := map[string]string(nil)
|
|
|
|
m2 := map[string]string{}
|
|
|
|
if h1, h2 := Hash(m1), Hash(m2); h1 == h2 {
|
|
|
|
t.Errorf("bogus: h1=%x, h2=%x", h1, h2)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestMapFraming(t *testing.T) {
|
|
|
|
m1 := map[string]string{"foo": "", "fo": "o"}
|
|
|
|
m2 := map[string]string{}
|
|
|
|
if h1, h2 := Hash(m1), Hash(m2); h1 == h2 {
|
|
|
|
t.Errorf("bogus: h1=%x, h2=%x", h1, h2)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestQuick(t *testing.T) {
|
|
|
|
initSeed()
|
|
|
|
err := quick.Check(func(v, w map[string]string) bool {
|
|
|
|
return (Hash(v) == Hash(w)) == reflect.DeepEqual(v, w)
|
|
|
|
}, &quick.Config{MaxCount: 1000, Rand: rand.New(rand.NewSource(int64(seed)))})
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("seed=%v, err=%v", seed, err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
util/deephash: always keep values addressable (#5328)
The logic of deephash is both simpler and easier to reason about
if values are always addressable.
In Go, the composite kinds are slices, arrays, maps, structs,
interfaces, pointers, channels, and functions,
where we define "composite" as a Go value that encapsulates
some other Go value (e.g., a map is a collection of key-value entries).
In the cases of pointers and slices, the sub-values are always addressable.
In the cases of arrays and structs, the sub-values are always addressable
if and only if the parent value is addressable.
In the case of maps and interfaces, the sub-values are never addressable.
To make them addressable, we need to copy them onto the heap.
For the purposes of deephash, we do not care about channels and functions.
For all non-composite kinds (e.g., strings and ints), they are only addressable
if obtained from one of the composite kinds that produce addressable values
(i.e., pointers, slices, addressable arrays, and addressable structs).
A non-addressible, non-composite kind can be made addressable by
allocating it on the heap, obtaining a pointer to it, and dereferencing it.
Thus, if we can ensure that values are addressable at the entry points,
and shallow copy sub-values whenever we encounter an interface or map,
then we can ensure that all values are always addressable and
assume such property throughout all the logic.
Performance:
name old time/op new time/op delta
Hash-24 21.5µs ± 1% 19.7µs ± 1% -8.29% (p=0.000 n=9+9)
HashPacketFilter-24 2.61µs ± 1% 2.62µs ± 0% +0.29% (p=0.037 n=10+9)
HashMapAcyclic-24 30.8µs ± 1% 30.9µs ± 1% ~ (p=0.400 n=9+10)
TailcfgNode-24 1.84µs ± 1% 1.84µs ± 2% ~ (p=0.928 n=10+10)
HashArray-24 324ns ± 2% 332ns ± 2% +2.45% (p=0.000 n=10+10)
Signed-off-by: Joe Tsai <joetsai@digital-static.net>
2022-08-10 05:00:02 +00:00
|
|
|
func getVal() any {
|
|
|
|
return &struct {
|
|
|
|
WGConfig *wgcfg.Config
|
|
|
|
RouterConfig *router.Config
|
|
|
|
MapFQDNAddrs map[dnsname.FQDN][]netip.Addr
|
|
|
|
MapFQDNAddrPorts map[dnsname.FQDN][]netip.AddrPort
|
|
|
|
MapDiscoPublics map[key.DiscoPublic]bool
|
|
|
|
MapResponse *tailcfg.MapResponse
|
|
|
|
FilterMatch filter.Match
|
|
|
|
}{
|
2020-06-28 17:58:21 +00:00
|
|
|
&wgcfg.Config{
|
2021-04-03 01:04:39 +00:00
|
|
|
Name: "foo",
|
2022-08-02 20:38:11 +00:00
|
|
|
Addresses: []netip.Prefix{netip.PrefixFrom(netip.AddrFrom16([16]byte{3: 3}).Unmap(), 5)},
|
2020-06-28 17:58:21 +00:00
|
|
|
Peers: []wgcfg.Peer{
|
|
|
|
{
|
2021-10-28 00:42:33 +00:00
|
|
|
PublicKey: key.NodePublic{},
|
2020-06-28 17:58:21 +00:00
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
&router.Config{
|
all: convert more code to use net/netip directly
perl -i -npe 's,netaddr.IPPrefixFrom,netip.PrefixFrom,' $(git grep -l -F netaddr.)
perl -i -npe 's,netaddr.IPPortFrom,netip.AddrPortFrom,' $(git grep -l -F netaddr. )
perl -i -npe 's,netaddr.IPPrefix,netip.Prefix,g' $(git grep -l -F netaddr. )
perl -i -npe 's,netaddr.IPPort,netip.AddrPort,g' $(git grep -l -F netaddr. )
perl -i -npe 's,netaddr.IP\b,netip.Addr,g' $(git grep -l -F netaddr. )
perl -i -npe 's,netaddr.IPv6Raw\b,netip.AddrFrom16,g' $(git grep -l -F netaddr. )
goimports -w .
Then delete some stuff from the net/netaddr shim package which is no
longer neeed.
Updates #5162
Change-Id: Ia7a86893fe21c7e3ee1ec823e8aba288d4566cd8
Signed-off-by: Brad Fitzpatrick <bradfitz@tailscale.com>
2022-07-26 04:14:09 +00:00
|
|
|
Routes: []netip.Prefix{
|
2022-07-26 03:55:44 +00:00
|
|
|
netip.MustParsePrefix("1.2.3.0/24"),
|
|
|
|
netip.MustParsePrefix("1234::/64"),
|
2020-07-14 13:12:00 +00:00
|
|
|
},
|
2020-06-28 17:58:21 +00:00
|
|
|
},
|
all: convert more code to use net/netip directly
perl -i -npe 's,netaddr.IPPrefixFrom,netip.PrefixFrom,' $(git grep -l -F netaddr.)
perl -i -npe 's,netaddr.IPPortFrom,netip.AddrPortFrom,' $(git grep -l -F netaddr. )
perl -i -npe 's,netaddr.IPPrefix,netip.Prefix,g' $(git grep -l -F netaddr. )
perl -i -npe 's,netaddr.IPPort,netip.AddrPort,g' $(git grep -l -F netaddr. )
perl -i -npe 's,netaddr.IP\b,netip.Addr,g' $(git grep -l -F netaddr. )
perl -i -npe 's,netaddr.IPv6Raw\b,netip.AddrFrom16,g' $(git grep -l -F netaddr. )
goimports -w .
Then delete some stuff from the net/netaddr shim package which is no
longer neeed.
Updates #5162
Change-Id: Ia7a86893fe21c7e3ee1ec823e8aba288d4566cd8
Signed-off-by: Brad Fitzpatrick <bradfitz@tailscale.com>
2022-07-26 04:14:09 +00:00
|
|
|
map[dnsname.FQDN][]netip.Addr{
|
2022-07-26 03:55:44 +00:00
|
|
|
dnsname.FQDN("a."): {netip.MustParseAddr("1.2.3.4"), netip.MustParseAddr("4.3.2.1")},
|
|
|
|
dnsname.FQDN("b."): {netip.MustParseAddr("8.8.8.8"), netip.MustParseAddr("9.9.9.9")},
|
|
|
|
dnsname.FQDN("c."): {netip.MustParseAddr("6.6.6.6"), netip.MustParseAddr("7.7.7.7")},
|
|
|
|
dnsname.FQDN("d."): {netip.MustParseAddr("6.7.6.6"), netip.MustParseAddr("7.7.7.8")},
|
|
|
|
dnsname.FQDN("e."): {netip.MustParseAddr("6.8.6.6"), netip.MustParseAddr("7.7.7.9")},
|
|
|
|
dnsname.FQDN("f."): {netip.MustParseAddr("6.9.6.6"), netip.MustParseAddr("7.7.7.0")},
|
2021-05-11 16:45:12 +00:00
|
|
|
},
|
all: convert more code to use net/netip directly
perl -i -npe 's,netaddr.IPPrefixFrom,netip.PrefixFrom,' $(git grep -l -F netaddr.)
perl -i -npe 's,netaddr.IPPortFrom,netip.AddrPortFrom,' $(git grep -l -F netaddr. )
perl -i -npe 's,netaddr.IPPrefix,netip.Prefix,g' $(git grep -l -F netaddr. )
perl -i -npe 's,netaddr.IPPort,netip.AddrPort,g' $(git grep -l -F netaddr. )
perl -i -npe 's,netaddr.IP\b,netip.Addr,g' $(git grep -l -F netaddr. )
perl -i -npe 's,netaddr.IPv6Raw\b,netip.AddrFrom16,g' $(git grep -l -F netaddr. )
goimports -w .
Then delete some stuff from the net/netaddr shim package which is no
longer neeed.
Updates #5162
Change-Id: Ia7a86893fe21c7e3ee1ec823e8aba288d4566cd8
Signed-off-by: Brad Fitzpatrick <bradfitz@tailscale.com>
2022-07-26 04:14:09 +00:00
|
|
|
map[dnsname.FQDN][]netip.AddrPort{
|
2022-07-26 03:55:44 +00:00
|
|
|
dnsname.FQDN("a."): {netip.MustParseAddrPort("1.2.3.4:11"), netip.MustParseAddrPort("4.3.2.1:22")},
|
|
|
|
dnsname.FQDN("b."): {netip.MustParseAddrPort("8.8.8.8:11"), netip.MustParseAddrPort("9.9.9.9:22")},
|
|
|
|
dnsname.FQDN("c."): {netip.MustParseAddrPort("8.8.8.8:12"), netip.MustParseAddrPort("9.9.9.9:23")},
|
|
|
|
dnsname.FQDN("d."): {netip.MustParseAddrPort("8.8.8.8:13"), netip.MustParseAddrPort("9.9.9.9:24")},
|
|
|
|
dnsname.FQDN("e."): {netip.MustParseAddrPort("8.8.8.8:14"), netip.MustParseAddrPort("9.9.9.9:25")},
|
2021-05-11 16:45:12 +00:00
|
|
|
},
|
2021-11-02 21:41:56 +00:00
|
|
|
map[key.DiscoPublic]bool{
|
|
|
|
key.DiscoPublicFromRaw32(mem.B([]byte{1: 1, 31: 0})): true,
|
|
|
|
key.DiscoPublicFromRaw32(mem.B([]byte{1: 2, 31: 0})): false,
|
|
|
|
key.DiscoPublicFromRaw32(mem.B([]byte{1: 3, 31: 0})): true,
|
|
|
|
key.DiscoPublicFromRaw32(mem.B([]byte{1: 4, 31: 0})): false,
|
2020-06-28 17:58:21 +00:00
|
|
|
},
|
2021-07-06 04:21:52 +00:00
|
|
|
&tailcfg.MapResponse{
|
|
|
|
DERPMap: &tailcfg.DERPMap{
|
|
|
|
Regions: map[int]*tailcfg.DERPRegion{
|
2021-12-15 16:42:25 +00:00
|
|
|
1: {
|
2021-07-06 04:21:52 +00:00
|
|
|
RegionID: 1,
|
|
|
|
RegionCode: "foo",
|
|
|
|
Nodes: []*tailcfg.DERPNode{
|
|
|
|
{
|
|
|
|
Name: "n1",
|
|
|
|
RegionID: 1,
|
|
|
|
HostName: "foo.com",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
Name: "n2",
|
|
|
|
RegionID: 1,
|
|
|
|
HostName: "bar.com",
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
DNSConfig: &tailcfg.DNSConfig{
|
2022-05-03 21:41:58 +00:00
|
|
|
Resolvers: []*dnstype.Resolver{
|
2021-07-06 04:21:52 +00:00
|
|
|
{Addr: "10.0.0.1"},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
PacketFilter: []tailcfg.FilterRule{
|
|
|
|
{
|
|
|
|
SrcIPs: []string{"1.2.3.4"},
|
|
|
|
DstPorts: []tailcfg.NetPortRange{
|
|
|
|
{
|
|
|
|
IP: "1.2.3.4/32",
|
2021-07-06 04:31:30 +00:00
|
|
|
Ports: tailcfg.PortRange{First: 1, Last: 2},
|
2021-07-06 04:21:52 +00:00
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
Peers: []*tailcfg.Node{
|
|
|
|
{
|
|
|
|
ID: 1,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
ID: 2,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
UserProfiles: []tailcfg.UserProfile{
|
|
|
|
{ID: 1, LoginName: "foo@bar.com"},
|
|
|
|
{ID: 2, LoginName: "bar@foo.com"},
|
|
|
|
},
|
|
|
|
},
|
2021-07-07 18:58:02 +00:00
|
|
|
filter.Match{
|
|
|
|
IPProto: []ipproto.Proto{1, 2, 3},
|
|
|
|
},
|
2020-06-28 17:58:21 +00:00
|
|
|
}
|
|
|
|
}
|
2021-05-08 01:05:04 +00:00
|
|
|
|
2022-06-15 05:49:11 +00:00
|
|
|
func TestTypeIsRecursive(t *testing.T) {
|
|
|
|
type RecursiveStruct struct {
|
|
|
|
v *RecursiveStruct
|
|
|
|
}
|
|
|
|
type RecursiveChan chan *RecursiveChan
|
|
|
|
|
|
|
|
tests := []struct {
|
|
|
|
val any
|
|
|
|
want bool
|
|
|
|
}{
|
|
|
|
{val: 42, want: false},
|
|
|
|
{val: "string", want: false},
|
|
|
|
{val: 1 + 2i, want: false},
|
|
|
|
{val: struct{}{}, want: false},
|
|
|
|
{val: (*RecursiveStruct)(nil), want: true},
|
|
|
|
{val: RecursiveStruct{}, want: true},
|
|
|
|
{val: time.Unix(0, 0), want: false},
|
|
|
|
{val: structs.Incomparable{}, want: false}, // ignore its [0]func()
|
|
|
|
{val: tailcfg.NetPortRange{}, want: false}, // uses structs.Incomparable
|
|
|
|
{val: (*tailcfg.Node)(nil), want: false},
|
|
|
|
{val: map[string]bool{}, want: false},
|
|
|
|
{val: func() {}, want: false},
|
|
|
|
{val: make(chan int), want: false},
|
|
|
|
{val: unsafe.Pointer(nil), want: false},
|
|
|
|
{val: make(RecursiveChan), want: true},
|
|
|
|
{val: make(chan int), want: false},
|
|
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
|
|
got := typeIsRecursive(reflect.TypeOf(tt.val))
|
|
|
|
if got != tt.want {
|
|
|
|
t.Errorf("for type %T: got %v, want %v", tt.val, got, tt.want)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-06-25 19:46:01 +00:00
|
|
|
type IntThenByte struct {
|
|
|
|
i int
|
|
|
|
b byte
|
|
|
|
}
|
|
|
|
|
|
|
|
type TwoInts struct{ a, b int }
|
|
|
|
|
|
|
|
type IntIntByteInt struct {
|
|
|
|
i1, i2 int32
|
|
|
|
b byte // padding after
|
|
|
|
i3 int32
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestCanMemHash(t *testing.T) {
|
|
|
|
tests := []struct {
|
|
|
|
val any
|
|
|
|
want bool
|
|
|
|
}{
|
|
|
|
{true, true},
|
|
|
|
{uint(1), true},
|
|
|
|
{uint8(1), true},
|
|
|
|
{uint16(1), true},
|
|
|
|
{uint32(1), true},
|
|
|
|
{uint64(1), true},
|
|
|
|
{uintptr(1), true},
|
|
|
|
{int(1), true},
|
|
|
|
{int8(1), true},
|
|
|
|
{int16(1), true},
|
|
|
|
{int32(1), true},
|
|
|
|
{int64(1), true},
|
|
|
|
{float32(1), true},
|
|
|
|
{float64(1), true},
|
|
|
|
{complex64(1), true},
|
|
|
|
{complex128(1), true},
|
|
|
|
{[32]byte{}, true},
|
|
|
|
{func() {}, false},
|
|
|
|
{make(chan int), false},
|
|
|
|
{struct{ io.Writer }{nil}, false},
|
|
|
|
{unsafe.Pointer(nil), false},
|
|
|
|
{new(int), false},
|
|
|
|
{TwoInts{}, true},
|
|
|
|
{[4]TwoInts{}, true},
|
|
|
|
{IntThenByte{}, false},
|
|
|
|
{[4]IntThenByte{}, false},
|
|
|
|
{tailcfg.PortRange{}, true},
|
|
|
|
{int16(0), true},
|
|
|
|
{struct {
|
|
|
|
_ int
|
|
|
|
_ int
|
|
|
|
}{}, true},
|
|
|
|
{struct {
|
|
|
|
_ int
|
|
|
|
_ uint8
|
|
|
|
_ int
|
|
|
|
}{}, false}, // gap
|
|
|
|
{
|
|
|
|
struct {
|
|
|
|
_ structs.Incomparable // if not last, zero-width
|
|
|
|
x int
|
|
|
|
}{},
|
|
|
|
true,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
struct {
|
|
|
|
x int
|
|
|
|
_ structs.Incomparable // zero-width last: has space, can't memhash
|
|
|
|
}{},
|
|
|
|
false,
|
|
|
|
}}
|
|
|
|
for _, tt := range tests {
|
|
|
|
got := canMemHash(reflect.TypeOf(tt.val))
|
|
|
|
if got != tt.want {
|
|
|
|
t.Errorf("for type %T: got %v, want %v", tt.val, got, tt.want)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-06-15 05:49:11 +00:00
|
|
|
func TestGetTypeHasher(t *testing.T) {
|
|
|
|
switch runtime.GOARCH {
|
|
|
|
case "amd64", "arm64", "arm", "386", "riscv64":
|
|
|
|
default:
|
|
|
|
// Test outputs below are specifically for little-endian machines.
|
|
|
|
// Just skip everything else for now. Feel free to add more above if
|
|
|
|
// you have the hardware to test and it's little-endian.
|
|
|
|
t.Skipf("skipping on %v", runtime.GOARCH)
|
|
|
|
}
|
|
|
|
type typedString string
|
|
|
|
var (
|
|
|
|
someInt = int('A')
|
|
|
|
someComplex128 = complex128(1 + 2i)
|
2022-07-26 03:55:44 +00:00
|
|
|
someIP = netip.MustParseAddr("1.2.3.4")
|
2022-06-15 05:49:11 +00:00
|
|
|
)
|
|
|
|
tests := []struct {
|
|
|
|
name string
|
|
|
|
val any
|
|
|
|
want bool // set true automatically if out != ""
|
|
|
|
out string
|
|
|
|
out32 string // overwrites out if 32-bit
|
|
|
|
}{
|
|
|
|
{
|
|
|
|
name: "int",
|
|
|
|
val: int(1),
|
|
|
|
out: "\x01\x00\x00\x00\x00\x00\x00\x00",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "int_negative",
|
|
|
|
val: int(-1),
|
|
|
|
out: "\xff\xff\xff\xff\xff\xff\xff\xff",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "int8",
|
|
|
|
val: int8(1),
|
|
|
|
out: "\x01",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "float64",
|
|
|
|
val: float64(1.0),
|
|
|
|
out: "\x00\x00\x00\x00\x00\x00\xf0?",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "float32",
|
|
|
|
val: float32(1.0),
|
|
|
|
out: "\x00\x00\x80?",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "string",
|
|
|
|
val: "foo",
|
|
|
|
out: "\x03\x00\x00\x00\x00\x00\x00\x00foo",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "typedString",
|
|
|
|
val: typedString("foo"),
|
|
|
|
out: "\x03\x00\x00\x00\x00\x00\x00\x00foo",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "string_slice",
|
|
|
|
val: []string{"foo", "bar"},
|
|
|
|
out: "\x02\x00\x00\x00\x00\x00\x00\x00\x03\x00\x00\x00\x00\x00\x00\x00foo\x03\x00\x00\x00\x00\x00\x00\x00bar",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "int_slice",
|
|
|
|
val: []int{1, 0, -1},
|
|
|
|
out: "\x03\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff",
|
|
|
|
out32: "\x03\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "struct",
|
|
|
|
val: struct {
|
|
|
|
a, b int
|
|
|
|
c uint16
|
|
|
|
}{1, -1, 2},
|
util/deephash: always keep values addressable (#5328)
The logic of deephash is both simpler and easier to reason about
if values are always addressable.
In Go, the composite kinds are slices, arrays, maps, structs,
interfaces, pointers, channels, and functions,
where we define "composite" as a Go value that encapsulates
some other Go value (e.g., a map is a collection of key-value entries).
In the cases of pointers and slices, the sub-values are always addressable.
In the cases of arrays and structs, the sub-values are always addressable
if and only if the parent value is addressable.
In the case of maps and interfaces, the sub-values are never addressable.
To make them addressable, we need to copy them onto the heap.
For the purposes of deephash, we do not care about channels and functions.
For all non-composite kinds (e.g., strings and ints), they are only addressable
if obtained from one of the composite kinds that produce addressable values
(i.e., pointers, slices, addressable arrays, and addressable structs).
A non-addressible, non-composite kind can be made addressable by
allocating it on the heap, obtaining a pointer to it, and dereferencing it.
Thus, if we can ensure that values are addressable at the entry points,
and shallow copy sub-values whenever we encounter an interface or map,
then we can ensure that all values are always addressable and
assume such property throughout all the logic.
Performance:
name old time/op new time/op delta
Hash-24 21.5µs ± 1% 19.7µs ± 1% -8.29% (p=0.000 n=9+9)
HashPacketFilter-24 2.61µs ± 1% 2.62µs ± 0% +0.29% (p=0.037 n=10+9)
HashMapAcyclic-24 30.8µs ± 1% 30.9µs ± 1% ~ (p=0.400 n=9+10)
TailcfgNode-24 1.84µs ± 1% 1.84µs ± 2% ~ (p=0.928 n=10+10)
HashArray-24 324ns ± 2% 332ns ± 2% +2.45% (p=0.000 n=10+10)
Signed-off-by: Joe Tsai <joetsai@digital-static.net>
2022-08-10 05:00:02 +00:00
|
|
|
out: "\x01\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x02\x00",
|
|
|
|
out32: "\x01\x00\x00\x00\xff\xff\xff\xff\x02\x00",
|
2022-06-15 05:49:11 +00:00
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "nil_int_ptr",
|
|
|
|
val: (*int)(nil),
|
|
|
|
out: "\x00",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "int_ptr",
|
|
|
|
val: &someInt,
|
|
|
|
out: "\x01A\x00\x00\x00\x00\x00\x00\x00",
|
|
|
|
out32: "\x01A\x00\x00\x00",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "nil_uint32_ptr",
|
|
|
|
val: (*uint32)(nil),
|
|
|
|
out: "\x00",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "complex128_ptr",
|
|
|
|
val: &someComplex128,
|
|
|
|
out: "\x01\x00\x00\x00\x00\x00\x00\xf0?\x00\x00\x00\x00\x00\x00\x00@",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "packet_filter",
|
|
|
|
val: filterRules,
|
|
|
|
out: "\x04\x00\x00\x00\x00\x00\x00\x00\x03\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00*\v\x00\x00\x00\x00\x00\x00\x0010.1.3.4/32\v\x00\x00\x00\x00\x00\x00\x0010.0.0.0/24\x03\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x03\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\n\x00\x00\x00\x00\x00\x00\x001.2.3.4/32\x01 \x00\x00\x00\x00\x00\x00\x00\x01\x00\x02\x00\x04\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x03\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\n\x00\x00\x00\x00\x00\x00\x001.2.3.4/32\x01\x00\x00\x00\x00\x00\x00\x00\x03\x00\x00\x00\x00\x00\x00\x00foo\x01\x00\x00\x00\x00\x00\x00\x00\v\x00\x00\x00\x00\x00\x00\x00foooooooooo\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\f\x00\x00\x00\x00\x00\x00\x00baaaaaarrrrr\x00\x01\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\v\x00\x00\x00\x00\x00\x00\x00foooooooooo\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\f\x00\x00\x00\x00\x00\x00\x00baaaaaarrrrr\x00\x01\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\v\x00\x00\x00\x00\x00\x00\x00foooooooooo\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\f\x00\x00\x00\x00\x00\x00\x00baaaaaarrrrr\x00\x01\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
|
|
|
|
out32: "\x04\x00\x00\x00\x00\x00\x00\x00\x03\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00*\v\x00\x00\x00\x00\x00\x00\x0010.1.3.4/32\v\x00\x00\x00\x00\x00\x00\x0010.0.0.0/24\x03\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\n\x00\x00\x00\x00\x00\x00\x001.2.3.4/32\x01 \x00\x00\x00\x01\x00\x02\x00\x04\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\n\x00\x00\x00\x00\x00\x00\x001.2.3.4/32\x01\x00\x00\x00\x00\x00\x00\x00\x03\x00\x00\x00\x00\x00\x00\x00foo\x01\x00\x00\x00\x00\x00\x00\x00\v\x00\x00\x00\x00\x00\x00\x00foooooooooo\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\f\x00\x00\x00\x00\x00\x00\x00baaaaaarrrrr\x00\x01\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\v\x00\x00\x00\x00\x00\x00\x00foooooooooo\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\f\x00\x00\x00\x00\x00\x00\x00baaaaaarrrrr\x00\x01\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\v\x00\x00\x00\x00\x00\x00\x00foooooooooo\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\f\x00\x00\x00\x00\x00\x00\x00baaaaaarrrrr\x00\x01\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
|
|
|
|
},
|
|
|
|
{
|
all: convert more code to use net/netip directly
perl -i -npe 's,netaddr.IPPrefixFrom,netip.PrefixFrom,' $(git grep -l -F netaddr.)
perl -i -npe 's,netaddr.IPPortFrom,netip.AddrPortFrom,' $(git grep -l -F netaddr. )
perl -i -npe 's,netaddr.IPPrefix,netip.Prefix,g' $(git grep -l -F netaddr. )
perl -i -npe 's,netaddr.IPPort,netip.AddrPort,g' $(git grep -l -F netaddr. )
perl -i -npe 's,netaddr.IP\b,netip.Addr,g' $(git grep -l -F netaddr. )
perl -i -npe 's,netaddr.IPv6Raw\b,netip.AddrFrom16,g' $(git grep -l -F netaddr. )
goimports -w .
Then delete some stuff from the net/netaddr shim package which is no
longer neeed.
Updates #5162
Change-Id: Ia7a86893fe21c7e3ee1ec823e8aba288d4566cd8
Signed-off-by: Brad Fitzpatrick <bradfitz@tailscale.com>
2022-07-26 04:14:09 +00:00
|
|
|
name: "netip.Addr",
|
2022-07-26 03:55:44 +00:00
|
|
|
val: netip.MustParseAddr("fe80::123%foo"),
|
2022-06-15 05:49:11 +00:00
|
|
|
out: "\r\x00\x00\x00\x00\x00\x00\x00fe80::123%foo",
|
|
|
|
},
|
|
|
|
{
|
all: convert more code to use net/netip directly
perl -i -npe 's,netaddr.IPPrefixFrom,netip.PrefixFrom,' $(git grep -l -F netaddr.)
perl -i -npe 's,netaddr.IPPortFrom,netip.AddrPortFrom,' $(git grep -l -F netaddr. )
perl -i -npe 's,netaddr.IPPrefix,netip.Prefix,g' $(git grep -l -F netaddr. )
perl -i -npe 's,netaddr.IPPort,netip.AddrPort,g' $(git grep -l -F netaddr. )
perl -i -npe 's,netaddr.IP\b,netip.Addr,g' $(git grep -l -F netaddr. )
perl -i -npe 's,netaddr.IPv6Raw\b,netip.AddrFrom16,g' $(git grep -l -F netaddr. )
goimports -w .
Then delete some stuff from the net/netaddr shim package which is no
longer neeed.
Updates #5162
Change-Id: Ia7a86893fe21c7e3ee1ec823e8aba288d4566cd8
Signed-off-by: Brad Fitzpatrick <bradfitz@tailscale.com>
2022-07-26 04:14:09 +00:00
|
|
|
name: "ptr-netip.Addr",
|
2022-06-15 05:49:11 +00:00
|
|
|
val: &someIP,
|
|
|
|
out: "\x01\a\x00\x00\x00\x00\x00\x00\x001.2.3.4",
|
|
|
|
},
|
|
|
|
{
|
all: convert more code to use net/netip directly
perl -i -npe 's,netaddr.IPPrefixFrom,netip.PrefixFrom,' $(git grep -l -F netaddr.)
perl -i -npe 's,netaddr.IPPortFrom,netip.AddrPortFrom,' $(git grep -l -F netaddr. )
perl -i -npe 's,netaddr.IPPrefix,netip.Prefix,g' $(git grep -l -F netaddr. )
perl -i -npe 's,netaddr.IPPort,netip.AddrPort,g' $(git grep -l -F netaddr. )
perl -i -npe 's,netaddr.IP\b,netip.Addr,g' $(git grep -l -F netaddr. )
perl -i -npe 's,netaddr.IPv6Raw\b,netip.AddrFrom16,g' $(git grep -l -F netaddr. )
goimports -w .
Then delete some stuff from the net/netaddr shim package which is no
longer neeed.
Updates #5162
Change-Id: Ia7a86893fe21c7e3ee1ec823e8aba288d4566cd8
Signed-off-by: Brad Fitzpatrick <bradfitz@tailscale.com>
2022-07-26 04:14:09 +00:00
|
|
|
name: "ptr-nil-netip.Addr",
|
|
|
|
val: (*netip.Addr)(nil),
|
2022-06-15 05:49:11 +00:00
|
|
|
out: "\x00",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "time",
|
|
|
|
val: time.Unix(0, 0).In(time.UTC),
|
|
|
|
out: "\x141970-01-01T00:00:00Z",
|
|
|
|
},
|
2022-07-27 16:10:22 +00:00
|
|
|
{
|
|
|
|
name: "time_ptr", // addressable, as opposed to "time" test above
|
|
|
|
val: ptrTo(time.Unix(0, 0).In(time.UTC)),
|
|
|
|
out: "\x01\x141970-01-01T00:00:00Z",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "time_ptr_via_unexported",
|
|
|
|
val: testtype.NewUnexportedAddressableTime(time.Unix(0, 0).In(time.UTC)),
|
|
|
|
out: "\x01\x141970-01-01T00:00:00Z",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "time_ptr_via_unexported_value",
|
|
|
|
val: *testtype.NewUnexportedAddressableTime(time.Unix(0, 0).In(time.UTC)),
|
util/deephash: always keep values addressable (#5328)
The logic of deephash is both simpler and easier to reason about
if values are always addressable.
In Go, the composite kinds are slices, arrays, maps, structs,
interfaces, pointers, channels, and functions,
where we define "composite" as a Go value that encapsulates
some other Go value (e.g., a map is a collection of key-value entries).
In the cases of pointers and slices, the sub-values are always addressable.
In the cases of arrays and structs, the sub-values are always addressable
if and only if the parent value is addressable.
In the case of maps and interfaces, the sub-values are never addressable.
To make them addressable, we need to copy them onto the heap.
For the purposes of deephash, we do not care about channels and functions.
For all non-composite kinds (e.g., strings and ints), they are only addressable
if obtained from one of the composite kinds that produce addressable values
(i.e., pointers, slices, addressable arrays, and addressable structs).
A non-addressible, non-composite kind can be made addressable by
allocating it on the heap, obtaining a pointer to it, and dereferencing it.
Thus, if we can ensure that values are addressable at the entry points,
and shallow copy sub-values whenever we encounter an interface or map,
then we can ensure that all values are always addressable and
assume such property throughout all the logic.
Performance:
name old time/op new time/op delta
Hash-24 21.5µs ± 1% 19.7µs ± 1% -8.29% (p=0.000 n=9+9)
HashPacketFilter-24 2.61µs ± 1% 2.62µs ± 0% +0.29% (p=0.037 n=10+9)
HashMapAcyclic-24 30.8µs ± 1% 30.9µs ± 1% ~ (p=0.400 n=9+10)
TailcfgNode-24 1.84µs ± 1% 1.84µs ± 2% ~ (p=0.928 n=10+10)
HashArray-24 324ns ± 2% 332ns ± 2% +2.45% (p=0.000 n=10+10)
Signed-off-by: Joe Tsai <joetsai@digital-static.net>
2022-08-10 05:00:02 +00:00
|
|
|
out: "\x141970-01-01T00:00:00Z",
|
2022-07-27 16:10:22 +00:00
|
|
|
},
|
2022-06-15 05:49:11 +00:00
|
|
|
{
|
|
|
|
name: "time_custom_zone",
|
|
|
|
val: time.Unix(1655311822, 0).In(time.FixedZone("FOO", -60*60)),
|
|
|
|
out: "\x192022-06-15T15:50:22-01:00",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "time_nil",
|
|
|
|
val: (*time.Time)(nil),
|
|
|
|
out: "\x00",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "array_memhash",
|
|
|
|
val: [4]byte{1, 2, 3, 4},
|
|
|
|
out: "\x01\x02\x03\x04",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "array_ptr_memhash",
|
|
|
|
val: ptrTo([4]byte{1, 2, 3, 4}),
|
|
|
|
out: "\x01\x01\x02\x03\x04",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "ptr_to_struct_partially_memhashable",
|
|
|
|
val: &struct {
|
|
|
|
A int16
|
|
|
|
B int16
|
|
|
|
C *int
|
|
|
|
}{5, 6, nil},
|
|
|
|
out: "\x01\x05\x00\x06\x00\x00",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "struct_partially_memhashable_but_cant_addr",
|
|
|
|
val: struct {
|
|
|
|
A int16
|
|
|
|
B int16
|
|
|
|
C *int
|
|
|
|
}{5, 6, nil},
|
|
|
|
out: "\x05\x00\x06\x00\x00",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "array_elements",
|
|
|
|
val: [4]byte{1, 2, 3, 4},
|
|
|
|
out: "\x01\x02\x03\x04",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "bool",
|
|
|
|
val: true,
|
|
|
|
out: "\x01",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "IntIntByteInt",
|
|
|
|
val: IntIntByteInt{1, 2, 3, 4},
|
|
|
|
out: "\x01\x00\x00\x00\x02\x00\x00\x00\x03\x04\x00\x00\x00",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "IntIntByteInt-canddr",
|
|
|
|
val: &IntIntByteInt{1, 2, 3, 4},
|
|
|
|
out: "\x01\x01\x00\x00\x00\x02\x00\x00\x00\x03\x04\x00\x00\x00",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "array-IntIntByteInt",
|
|
|
|
val: [2]IntIntByteInt{
|
|
|
|
{1, 2, 3, 4},
|
|
|
|
{5, 6, 7, 8},
|
|
|
|
},
|
|
|
|
out: "\x01\x00\x00\x00\x02\x00\x00\x00\x03\x04\x00\x00\x00\x05\x00\x00\x00\x06\x00\x00\x00\a\b\x00\x00\x00",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "array-IntIntByteInt-canaddr",
|
|
|
|
val: &[2]IntIntByteInt{
|
|
|
|
{1, 2, 3, 4},
|
|
|
|
{5, 6, 7, 8},
|
|
|
|
},
|
|
|
|
out: "\x01\x01\x00\x00\x00\x02\x00\x00\x00\x03\x04\x00\x00\x00\x05\x00\x00\x00\x06\x00\x00\x00\a\b\x00\x00\x00",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "tailcfg.Node",
|
|
|
|
val: &tailcfg.Node{},
|
|
|
|
out: "\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x140001-01-01T00:00:00Z\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x140001-01-01T00:00:00Z\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
|
|
|
|
},
|
|
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
|
|
rv := reflect.ValueOf(tt.val)
|
util/deephash: always keep values addressable (#5328)
The logic of deephash is both simpler and easier to reason about
if values are always addressable.
In Go, the composite kinds are slices, arrays, maps, structs,
interfaces, pointers, channels, and functions,
where we define "composite" as a Go value that encapsulates
some other Go value (e.g., a map is a collection of key-value entries).
In the cases of pointers and slices, the sub-values are always addressable.
In the cases of arrays and structs, the sub-values are always addressable
if and only if the parent value is addressable.
In the case of maps and interfaces, the sub-values are never addressable.
To make them addressable, we need to copy them onto the heap.
For the purposes of deephash, we do not care about channels and functions.
For all non-composite kinds (e.g., strings and ints), they are only addressable
if obtained from one of the composite kinds that produce addressable values
(i.e., pointers, slices, addressable arrays, and addressable structs).
A non-addressible, non-composite kind can be made addressable by
allocating it on the heap, obtaining a pointer to it, and dereferencing it.
Thus, if we can ensure that values are addressable at the entry points,
and shallow copy sub-values whenever we encounter an interface or map,
then we can ensure that all values are always addressable and
assume such property throughout all the logic.
Performance:
name old time/op new time/op delta
Hash-24 21.5µs ± 1% 19.7µs ± 1% -8.29% (p=0.000 n=9+9)
HashPacketFilter-24 2.61µs ± 1% 2.62µs ± 0% +0.29% (p=0.037 n=10+9)
HashMapAcyclic-24 30.8µs ± 1% 30.9µs ± 1% ~ (p=0.400 n=9+10)
TailcfgNode-24 1.84µs ± 1% 1.84µs ± 2% ~ (p=0.928 n=10+10)
HashArray-24 324ns ± 2% 332ns ± 2% +2.45% (p=0.000 n=10+10)
Signed-off-by: Joe Tsai <joetsai@digital-static.net>
2022-08-10 05:00:02 +00:00
|
|
|
va := newAddressableValue(rv.Type())
|
|
|
|
va.Set(rv)
|
|
|
|
fn := getTypeInfo(va.Type()).hasher()
|
2022-08-12 00:44:09 +00:00
|
|
|
hb := &hashBuffer{Hash: sha256.New()}
|
|
|
|
h := new(hasher)
|
|
|
|
h.Hash.H = hb
|
util/deephash: always keep values addressable (#5328)
The logic of deephash is both simpler and easier to reason about
if values are always addressable.
In Go, the composite kinds are slices, arrays, maps, structs,
interfaces, pointers, channels, and functions,
where we define "composite" as a Go value that encapsulates
some other Go value (e.g., a map is a collection of key-value entries).
In the cases of pointers and slices, the sub-values are always addressable.
In the cases of arrays and structs, the sub-values are always addressable
if and only if the parent value is addressable.
In the case of maps and interfaces, the sub-values are never addressable.
To make them addressable, we need to copy them onto the heap.
For the purposes of deephash, we do not care about channels and functions.
For all non-composite kinds (e.g., strings and ints), they are only addressable
if obtained from one of the composite kinds that produce addressable values
(i.e., pointers, slices, addressable arrays, and addressable structs).
A non-addressible, non-composite kind can be made addressable by
allocating it on the heap, obtaining a pointer to it, and dereferencing it.
Thus, if we can ensure that values are addressable at the entry points,
and shallow copy sub-values whenever we encounter an interface or map,
then we can ensure that all values are always addressable and
assume such property throughout all the logic.
Performance:
name old time/op new time/op delta
Hash-24 21.5µs ± 1% 19.7µs ± 1% -8.29% (p=0.000 n=9+9)
HashPacketFilter-24 2.61µs ± 1% 2.62µs ± 0% +0.29% (p=0.037 n=10+9)
HashMapAcyclic-24 30.8µs ± 1% 30.9µs ± 1% ~ (p=0.400 n=9+10)
TailcfgNode-24 1.84µs ± 1% 1.84µs ± 2% ~ (p=0.928 n=10+10)
HashArray-24 324ns ± 2% 332ns ± 2% +2.45% (p=0.000 n=10+10)
Signed-off-by: Joe Tsai <joetsai@digital-static.net>
2022-08-10 05:00:02 +00:00
|
|
|
got := fn(h, va)
|
2022-06-15 05:49:11 +00:00
|
|
|
const ptrSize = 32 << uintptr(^uintptr(0)>>63)
|
|
|
|
if tt.out32 != "" && ptrSize == 32 {
|
|
|
|
tt.out = tt.out32
|
|
|
|
}
|
|
|
|
if tt.out != "" {
|
|
|
|
tt.want = true
|
|
|
|
}
|
|
|
|
if got != tt.want {
|
|
|
|
t.Fatalf("func returned %v; want %v", got, tt.want)
|
|
|
|
}
|
2022-08-12 00:44:09 +00:00
|
|
|
h.sum()
|
|
|
|
if got := string(hb.B); got != tt.out {
|
2022-06-15 05:49:11 +00:00
|
|
|
t.Fatalf("got %q; want %q", got, tt.out)
|
|
|
|
}
|
|
|
|
})
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
util/deephash: always keep values addressable (#5328)
The logic of deephash is both simpler and easier to reason about
if values are always addressable.
In Go, the composite kinds are slices, arrays, maps, structs,
interfaces, pointers, channels, and functions,
where we define "composite" as a Go value that encapsulates
some other Go value (e.g., a map is a collection of key-value entries).
In the cases of pointers and slices, the sub-values are always addressable.
In the cases of arrays and structs, the sub-values are always addressable
if and only if the parent value is addressable.
In the case of maps and interfaces, the sub-values are never addressable.
To make them addressable, we need to copy them onto the heap.
For the purposes of deephash, we do not care about channels and functions.
For all non-composite kinds (e.g., strings and ints), they are only addressable
if obtained from one of the composite kinds that produce addressable values
(i.e., pointers, slices, addressable arrays, and addressable structs).
A non-addressible, non-composite kind can be made addressable by
allocating it on the heap, obtaining a pointer to it, and dereferencing it.
Thus, if we can ensure that values are addressable at the entry points,
and shallow copy sub-values whenever we encounter an interface or map,
then we can ensure that all values are always addressable and
assume such property throughout all the logic.
Performance:
name old time/op new time/op delta
Hash-24 21.5µs ± 1% 19.7µs ± 1% -8.29% (p=0.000 n=9+9)
HashPacketFilter-24 2.61µs ± 1% 2.62µs ± 0% +0.29% (p=0.037 n=10+9)
HashMapAcyclic-24 30.8µs ± 1% 30.9µs ± 1% ~ (p=0.400 n=9+10)
TailcfgNode-24 1.84µs ± 1% 1.84µs ± 2% ~ (p=0.928 n=10+10)
HashArray-24 324ns ± 2% 332ns ± 2% +2.45% (p=0.000 n=10+10)
Signed-off-by: Joe Tsai <joetsai@digital-static.net>
2022-08-10 05:00:02 +00:00
|
|
|
var sink Sum
|
2021-07-05 04:25:15 +00:00
|
|
|
|
2021-05-08 01:05:04 +00:00
|
|
|
func BenchmarkHash(b *testing.B) {
|
|
|
|
b.ReportAllocs()
|
|
|
|
v := getVal()
|
|
|
|
for i := 0; i < b.N; i++ {
|
2021-07-05 04:25:15 +00:00
|
|
|
sink = Hash(v)
|
2021-05-08 01:05:04 +00:00
|
|
|
}
|
|
|
|
}
|
2021-05-11 20:17:12 +00:00
|
|
|
|
2022-06-25 19:26:54 +00:00
|
|
|
func ptrTo[T any](v T) *T { return &v }
|
|
|
|
|
|
|
|
// filterRules is a packet filter that has both everything populated (in its
|
|
|
|
// first element) and also a few entries that are the typical shape for regular
|
|
|
|
// packet filters as sent to clients.
|
|
|
|
var filterRules = []tailcfg.FilterRule{
|
|
|
|
{
|
|
|
|
SrcIPs: []string{"*", "10.1.3.4/32", "10.0.0.0/24"},
|
|
|
|
SrcBits: []int{1, 2, 3},
|
|
|
|
DstPorts: []tailcfg.NetPortRange{{
|
|
|
|
IP: "1.2.3.4/32",
|
|
|
|
Bits: ptrTo(32),
|
|
|
|
Ports: tailcfg.PortRange{First: 1, Last: 2},
|
|
|
|
}},
|
|
|
|
IPProto: []int{1, 2, 3, 4},
|
|
|
|
CapGrant: []tailcfg.CapGrant{{
|
all: convert more code to use net/netip directly
perl -i -npe 's,netaddr.IPPrefixFrom,netip.PrefixFrom,' $(git grep -l -F netaddr.)
perl -i -npe 's,netaddr.IPPortFrom,netip.AddrPortFrom,' $(git grep -l -F netaddr. )
perl -i -npe 's,netaddr.IPPrefix,netip.Prefix,g' $(git grep -l -F netaddr. )
perl -i -npe 's,netaddr.IPPort,netip.AddrPort,g' $(git grep -l -F netaddr. )
perl -i -npe 's,netaddr.IP\b,netip.Addr,g' $(git grep -l -F netaddr. )
perl -i -npe 's,netaddr.IPv6Raw\b,netip.AddrFrom16,g' $(git grep -l -F netaddr. )
goimports -w .
Then delete some stuff from the net/netaddr shim package which is no
longer neeed.
Updates #5162
Change-Id: Ia7a86893fe21c7e3ee1ec823e8aba288d4566cd8
Signed-off-by: Brad Fitzpatrick <bradfitz@tailscale.com>
2022-07-26 04:14:09 +00:00
|
|
|
Dsts: []netip.Prefix{netip.MustParsePrefix("1.2.3.4/32")},
|
2022-06-25 19:26:54 +00:00
|
|
|
Caps: []string{"foo"},
|
|
|
|
}},
|
|
|
|
},
|
|
|
|
{
|
|
|
|
SrcIPs: []string{"foooooooooo"},
|
|
|
|
DstPorts: []tailcfg.NetPortRange{{
|
|
|
|
IP: "baaaaaarrrrr",
|
|
|
|
Ports: tailcfg.PortRange{First: 1, Last: 2},
|
|
|
|
}},
|
|
|
|
},
|
|
|
|
{
|
|
|
|
SrcIPs: []string{"foooooooooo"},
|
|
|
|
DstPorts: []tailcfg.NetPortRange{{
|
|
|
|
IP: "baaaaaarrrrr",
|
|
|
|
Ports: tailcfg.PortRange{First: 1, Last: 2},
|
|
|
|
}},
|
|
|
|
},
|
|
|
|
{
|
|
|
|
SrcIPs: []string{"foooooooooo"},
|
|
|
|
DstPorts: []tailcfg.NetPortRange{{
|
|
|
|
IP: "baaaaaarrrrr",
|
|
|
|
Ports: tailcfg.PortRange{First: 1, Last: 2},
|
|
|
|
}},
|
|
|
|
},
|
|
|
|
}
|
|
|
|
|
|
|
|
func BenchmarkHashPacketFilter(b *testing.B) {
|
|
|
|
b.ReportAllocs()
|
|
|
|
|
util/deephash: always keep values addressable (#5328)
The logic of deephash is both simpler and easier to reason about
if values are always addressable.
In Go, the composite kinds are slices, arrays, maps, structs,
interfaces, pointers, channels, and functions,
where we define "composite" as a Go value that encapsulates
some other Go value (e.g., a map is a collection of key-value entries).
In the cases of pointers and slices, the sub-values are always addressable.
In the cases of arrays and structs, the sub-values are always addressable
if and only if the parent value is addressable.
In the case of maps and interfaces, the sub-values are never addressable.
To make them addressable, we need to copy them onto the heap.
For the purposes of deephash, we do not care about channels and functions.
For all non-composite kinds (e.g., strings and ints), they are only addressable
if obtained from one of the composite kinds that produce addressable values
(i.e., pointers, slices, addressable arrays, and addressable structs).
A non-addressible, non-composite kind can be made addressable by
allocating it on the heap, obtaining a pointer to it, and dereferencing it.
Thus, if we can ensure that values are addressable at the entry points,
and shallow copy sub-values whenever we encounter an interface or map,
then we can ensure that all values are always addressable and
assume such property throughout all the logic.
Performance:
name old time/op new time/op delta
Hash-24 21.5µs ± 1% 19.7µs ± 1% -8.29% (p=0.000 n=9+9)
HashPacketFilter-24 2.61µs ± 1% 2.62µs ± 0% +0.29% (p=0.037 n=10+9)
HashMapAcyclic-24 30.8µs ± 1% 30.9µs ± 1% ~ (p=0.400 n=9+10)
TailcfgNode-24 1.84µs ± 1% 1.84µs ± 2% ~ (p=0.928 n=10+10)
HashArray-24 324ns ± 2% 332ns ± 2% +2.45% (p=0.000 n=10+10)
Signed-off-by: Joe Tsai <joetsai@digital-static.net>
2022-08-10 05:00:02 +00:00
|
|
|
hash := HasherForType[*[]tailcfg.FilterRule]()
|
2022-06-25 19:26:54 +00:00
|
|
|
for i := 0; i < b.N; i++ {
|
util/deephash: always keep values addressable (#5328)
The logic of deephash is both simpler and easier to reason about
if values are always addressable.
In Go, the composite kinds are slices, arrays, maps, structs,
interfaces, pointers, channels, and functions,
where we define "composite" as a Go value that encapsulates
some other Go value (e.g., a map is a collection of key-value entries).
In the cases of pointers and slices, the sub-values are always addressable.
In the cases of arrays and structs, the sub-values are always addressable
if and only if the parent value is addressable.
In the case of maps and interfaces, the sub-values are never addressable.
To make them addressable, we need to copy them onto the heap.
For the purposes of deephash, we do not care about channels and functions.
For all non-composite kinds (e.g., strings and ints), they are only addressable
if obtained from one of the composite kinds that produce addressable values
(i.e., pointers, slices, addressable arrays, and addressable structs).
A non-addressible, non-composite kind can be made addressable by
allocating it on the heap, obtaining a pointer to it, and dereferencing it.
Thus, if we can ensure that values are addressable at the entry points,
and shallow copy sub-values whenever we encounter an interface or map,
then we can ensure that all values are always addressable and
assume such property throughout all the logic.
Performance:
name old time/op new time/op delta
Hash-24 21.5µs ± 1% 19.7µs ± 1% -8.29% (p=0.000 n=9+9)
HashPacketFilter-24 2.61µs ± 1% 2.62µs ± 0% +0.29% (p=0.037 n=10+9)
HashMapAcyclic-24 30.8µs ± 1% 30.9µs ± 1% ~ (p=0.400 n=9+10)
TailcfgNode-24 1.84µs ± 1% 1.84µs ± 2% ~ (p=0.928 n=10+10)
HashArray-24 324ns ± 2% 332ns ± 2% +2.45% (p=0.000 n=10+10)
Signed-off-by: Joe Tsai <joetsai@digital-static.net>
2022-08-10 05:00:02 +00:00
|
|
|
sink = hash(&filterRules)
|
2022-06-25 19:26:54 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-05-11 20:17:12 +00:00
|
|
|
func TestHashMapAcyclic(t *testing.T) {
|
|
|
|
m := map[int]string{}
|
|
|
|
for i := 0; i < 100; i++ {
|
|
|
|
m[i] = fmt.Sprint(i)
|
|
|
|
}
|
|
|
|
got := map[string]bool{}
|
|
|
|
|
2022-08-12 00:44:09 +00:00
|
|
|
hb := &hashBuffer{Hash: sha256.New()}
|
2021-05-11 20:17:12 +00:00
|
|
|
|
2022-06-15 05:49:11 +00:00
|
|
|
ti := getTypeInfo(reflect.TypeOf(m))
|
|
|
|
|
2021-05-11 20:17:12 +00:00
|
|
|
for i := 0; i < 20; i++ {
|
util/deephash: always keep values addressable (#5328)
The logic of deephash is both simpler and easier to reason about
if values are always addressable.
In Go, the composite kinds are slices, arrays, maps, structs,
interfaces, pointers, channels, and functions,
where we define "composite" as a Go value that encapsulates
some other Go value (e.g., a map is a collection of key-value entries).
In the cases of pointers and slices, the sub-values are always addressable.
In the cases of arrays and structs, the sub-values are always addressable
if and only if the parent value is addressable.
In the case of maps and interfaces, the sub-values are never addressable.
To make them addressable, we need to copy them onto the heap.
For the purposes of deephash, we do not care about channels and functions.
For all non-composite kinds (e.g., strings and ints), they are only addressable
if obtained from one of the composite kinds that produce addressable values
(i.e., pointers, slices, addressable arrays, and addressable structs).
A non-addressible, non-composite kind can be made addressable by
allocating it on the heap, obtaining a pointer to it, and dereferencing it.
Thus, if we can ensure that values are addressable at the entry points,
and shallow copy sub-values whenever we encounter an interface or map,
then we can ensure that all values are always addressable and
assume such property throughout all the logic.
Performance:
name old time/op new time/op delta
Hash-24 21.5µs ± 1% 19.7µs ± 1% -8.29% (p=0.000 n=9+9)
HashPacketFilter-24 2.61µs ± 1% 2.62µs ± 0% +0.29% (p=0.037 n=10+9)
HashMapAcyclic-24 30.8µs ± 1% 30.9µs ± 1% ~ (p=0.400 n=9+10)
TailcfgNode-24 1.84µs ± 1% 1.84µs ± 2% ~ (p=0.928 n=10+10)
HashArray-24 324ns ± 2% 332ns ± 2% +2.45% (p=0.000 n=10+10)
Signed-off-by: Joe Tsai <joetsai@digital-static.net>
2022-08-10 05:00:02 +00:00
|
|
|
v := addressableValue{reflect.ValueOf(&m).Elem()}
|
2022-08-12 00:44:09 +00:00
|
|
|
hb.Reset()
|
|
|
|
h := new(hasher)
|
|
|
|
h.Hash.H = hb
|
2022-06-15 05:49:11 +00:00
|
|
|
h.hashMap(v, ti, false)
|
2022-08-12 00:44:09 +00:00
|
|
|
h.sum()
|
|
|
|
if got[string(hb.B)] {
|
2021-05-11 20:17:12 +00:00
|
|
|
continue
|
|
|
|
}
|
2022-08-12 00:44:09 +00:00
|
|
|
got[string(hb.B)] = true
|
2021-05-11 20:17:12 +00:00
|
|
|
}
|
|
|
|
if len(got) != 1 {
|
|
|
|
t.Errorf("got %d results; want 1", len(got))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-07-06 05:13:33 +00:00
|
|
|
func TestPrintArray(t *testing.T) {
|
|
|
|
type T struct {
|
|
|
|
X [32]byte
|
|
|
|
}
|
2021-07-22 22:22:48 +00:00
|
|
|
x := T{X: [32]byte{1: 1, 31: 31}}
|
2022-08-12 00:44:09 +00:00
|
|
|
hb := &hashBuffer{Hash: sha256.New()}
|
|
|
|
h := new(hasher)
|
|
|
|
h.Hash.H = hb
|
util/deephash: always keep values addressable (#5328)
The logic of deephash is both simpler and easier to reason about
if values are always addressable.
In Go, the composite kinds are slices, arrays, maps, structs,
interfaces, pointers, channels, and functions,
where we define "composite" as a Go value that encapsulates
some other Go value (e.g., a map is a collection of key-value entries).
In the cases of pointers and slices, the sub-values are always addressable.
In the cases of arrays and structs, the sub-values are always addressable
if and only if the parent value is addressable.
In the case of maps and interfaces, the sub-values are never addressable.
To make them addressable, we need to copy them onto the heap.
For the purposes of deephash, we do not care about channels and functions.
For all non-composite kinds (e.g., strings and ints), they are only addressable
if obtained from one of the composite kinds that produce addressable values
(i.e., pointers, slices, addressable arrays, and addressable structs).
A non-addressible, non-composite kind can be made addressable by
allocating it on the heap, obtaining a pointer to it, and dereferencing it.
Thus, if we can ensure that values are addressable at the entry points,
and shallow copy sub-values whenever we encounter an interface or map,
then we can ensure that all values are always addressable and
assume such property throughout all the logic.
Performance:
name old time/op new time/op delta
Hash-24 21.5µs ± 1% 19.7µs ± 1% -8.29% (p=0.000 n=9+9)
HashPacketFilter-24 2.61µs ± 1% 2.62µs ± 0% +0.29% (p=0.037 n=10+9)
HashMapAcyclic-24 30.8µs ± 1% 30.9µs ± 1% ~ (p=0.400 n=9+10)
TailcfgNode-24 1.84µs ± 1% 1.84µs ± 2% ~ (p=0.928 n=10+10)
HashArray-24 324ns ± 2% 332ns ± 2% +2.45% (p=0.000 n=10+10)
Signed-off-by: Joe Tsai <joetsai@digital-static.net>
2022-08-10 05:00:02 +00:00
|
|
|
h.hashValue(addressableValue{reflect.ValueOf(&x).Elem()}, false)
|
2022-08-12 00:44:09 +00:00
|
|
|
h.sum()
|
util/deephash: remove unnecessary formatting for structs and slices (#2571)
The index for every struct field or slice element and
the number of fields for the struct is unncessary.
The hashing of Go values is unambiguous because every type (except maps)
encodes in a parsable manner. So long as we know the type information,
we could theoretically decode every value (except for maps).
At a high level:
* numbers are encoded as fixed-width records according to precision.
* strings (and AppendTo output) are encoded with a fixed-width length,
followed by the contents of the buffer.
* slices are prefixed by a fixed-width length, followed by the encoding
of each value. So long as we know the type of each element, we could
theoretically decode each element.
* arrays are encoded just like slices, but elide the length
since it is determined from the Go type.
* maps are encoded first with a byte indicating whether it is a cycle.
If a cycle, it is followed by a fixed-width index for the pointer,
otherwise followed by the SHA-256 hash of its contents. The encoding of maps
is not decodeable, but a SHA-256 hash is sufficient to avoid ambiguities.
* interfaces are encoded first with a byte indicating whether it is nil.
If not nil, it is followed by a fixed-width index for the type,
and then the encoding for the underlying value. Having the type be encoded
first ensures that the value could theoretically be decoded next.
* pointers are encoded first with a byte indicating whether it is
1) nil, 2) a cycle, or 3) newly seen. If a cycle, it is followed by
a fixed-width index for the pointer. If newly seen, it is followed by
the encoding for the pointed-at value.
Removing unnecessary details speeds up hashing:
name old time/op new time/op delta
Hash-8 76.0µs ± 1% 55.8µs ± 2% -26.62% (p=0.000 n=10+10)
HashMapAcyclic-8 61.9µs ± 0% 62.0µs ± 0% ~ (p=0.666 n=9+9)
TailcfgNode-8 10.2µs ± 1% 7.5µs ± 1% -26.90% (p=0.000 n=10+9)
HashArray-8 1.07µs ± 1% 0.70µs ± 1% -34.67% (p=0.000 n=10+9)
Signed-off-by: Joe Tsai <joetsai@digital-static.net>
2021-08-04 03:35:57 +00:00
|
|
|
const want = "\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1f"
|
2022-08-12 00:44:09 +00:00
|
|
|
if got := hb.B; string(got) != want {
|
2021-07-06 05:13:33 +00:00
|
|
|
t.Errorf("wrong:\n got: %q\nwant: %q\n", got, want)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-05-11 20:17:12 +00:00
|
|
|
func BenchmarkHashMapAcyclic(b *testing.B) {
|
|
|
|
b.ReportAllocs()
|
|
|
|
m := map[int]string{}
|
|
|
|
for i := 0; i < 100; i++ {
|
|
|
|
m[i] = fmt.Sprint(i)
|
|
|
|
}
|
|
|
|
|
2022-08-12 00:44:09 +00:00
|
|
|
hb := &hashBuffer{Hash: sha256.New()}
|
util/deephash: always keep values addressable (#5328)
The logic of deephash is both simpler and easier to reason about
if values are always addressable.
In Go, the composite kinds are slices, arrays, maps, structs,
interfaces, pointers, channels, and functions,
where we define "composite" as a Go value that encapsulates
some other Go value (e.g., a map is a collection of key-value entries).
In the cases of pointers and slices, the sub-values are always addressable.
In the cases of arrays and structs, the sub-values are always addressable
if and only if the parent value is addressable.
In the case of maps and interfaces, the sub-values are never addressable.
To make them addressable, we need to copy them onto the heap.
For the purposes of deephash, we do not care about channels and functions.
For all non-composite kinds (e.g., strings and ints), they are only addressable
if obtained from one of the composite kinds that produce addressable values
(i.e., pointers, slices, addressable arrays, and addressable structs).
A non-addressible, non-composite kind can be made addressable by
allocating it on the heap, obtaining a pointer to it, and dereferencing it.
Thus, if we can ensure that values are addressable at the entry points,
and shallow copy sub-values whenever we encounter an interface or map,
then we can ensure that all values are always addressable and
assume such property throughout all the logic.
Performance:
name old time/op new time/op delta
Hash-24 21.5µs ± 1% 19.7µs ± 1% -8.29% (p=0.000 n=9+9)
HashPacketFilter-24 2.61µs ± 1% 2.62µs ± 0% +0.29% (p=0.037 n=10+9)
HashMapAcyclic-24 30.8µs ± 1% 30.9µs ± 1% ~ (p=0.400 n=9+10)
TailcfgNode-24 1.84µs ± 1% 1.84µs ± 2% ~ (p=0.928 n=10+10)
HashArray-24 324ns ± 2% 332ns ± 2% +2.45% (p=0.000 n=10+10)
Signed-off-by: Joe Tsai <joetsai@digital-static.net>
2022-08-10 05:00:02 +00:00
|
|
|
v := addressableValue{reflect.ValueOf(&m).Elem()}
|
2022-06-15 05:49:11 +00:00
|
|
|
ti := getTypeInfo(v.Type())
|
2021-05-11 20:17:12 +00:00
|
|
|
|
2022-08-12 00:44:09 +00:00
|
|
|
h := new(hasher)
|
|
|
|
h.Hash.H = hb
|
2021-07-07 05:37:32 +00:00
|
|
|
|
2021-05-11 20:17:12 +00:00
|
|
|
for i := 0; i < b.N; i++ {
|
2022-08-12 00:44:09 +00:00
|
|
|
h.Reset()
|
2022-06-15 05:49:11 +00:00
|
|
|
h.hashMap(v, ti, false)
|
2021-05-11 20:17:12 +00:00
|
|
|
}
|
|
|
|
}
|
2021-07-02 20:45:23 +00:00
|
|
|
|
2021-07-06 04:21:52 +00:00
|
|
|
func BenchmarkTailcfgNode(b *testing.B) {
|
|
|
|
b.ReportAllocs()
|
|
|
|
|
|
|
|
node := new(tailcfg.Node)
|
|
|
|
for i := 0; i < b.N; i++ {
|
|
|
|
sink = Hash(node)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-07-02 20:45:23 +00:00
|
|
|
func TestExhaustive(t *testing.T) {
|
2021-07-20 05:49:51 +00:00
|
|
|
seen := make(map[Sum]bool)
|
2021-07-02 20:45:23 +00:00
|
|
|
for i := 0; i < 100000; i++ {
|
2021-07-05 04:25:15 +00:00
|
|
|
s := Hash(i)
|
2021-07-02 20:45:23 +00:00
|
|
|
if seen[s] {
|
|
|
|
t.Fatalf("hash collision %v", i)
|
|
|
|
}
|
|
|
|
seen[s] = true
|
|
|
|
}
|
|
|
|
}
|
2021-07-05 04:25:15 +00:00
|
|
|
|
2021-07-07 04:41:18 +00:00
|
|
|
// verify this doesn't loop forever, as it used to (Issue 2340)
|
|
|
|
func TestMapCyclicFallback(t *testing.T) {
|
|
|
|
type T struct {
|
2022-03-16 23:27:57 +00:00
|
|
|
M map[string]any
|
2021-07-07 04:41:18 +00:00
|
|
|
}
|
|
|
|
v := &T{
|
2022-03-16 23:27:57 +00:00
|
|
|
M: map[string]any{},
|
2021-07-07 04:41:18 +00:00
|
|
|
}
|
|
|
|
v.M["m"] = v.M
|
|
|
|
Hash(v)
|
|
|
|
}
|
2021-07-06 05:13:33 +00:00
|
|
|
|
|
|
|
func TestArrayAllocs(t *testing.T) {
|
2021-07-07 18:40:28 +00:00
|
|
|
if version.IsRace() {
|
|
|
|
t.Skip("skipping test under race detector")
|
|
|
|
}
|
2021-08-30 17:47:21 +00:00
|
|
|
|
|
|
|
// In theory, there should be no allocations. However, escape analysis on
|
|
|
|
// certain architectures fails to detect that certain cases do not escape.
|
|
|
|
// This discrepency currently affects sha256.digest.Sum.
|
|
|
|
// Measure the number of allocations in sha256 to ensure that Hash does
|
|
|
|
// not allocate on top of its usage of sha256.
|
|
|
|
// See https://golang.org/issue/48055.
|
|
|
|
var b []byte
|
|
|
|
h := sha256.New()
|
|
|
|
want := int(testing.AllocsPerRun(1000, func() {
|
|
|
|
b = h.Sum(b[:0])
|
|
|
|
}))
|
|
|
|
switch runtime.GOARCH {
|
|
|
|
case "amd64", "arm64":
|
|
|
|
want = 0 // ensure no allocations on popular architectures
|
|
|
|
}
|
|
|
|
|
2021-07-06 05:13:33 +00:00
|
|
|
type T struct {
|
|
|
|
X [32]byte
|
|
|
|
}
|
|
|
|
x := &T{X: [32]byte{1: 1, 2: 2, 3: 3, 4: 4}}
|
2021-08-30 17:47:21 +00:00
|
|
|
got := int(testing.AllocsPerRun(1000, func() {
|
2021-07-06 05:13:33 +00:00
|
|
|
sink = Hash(x)
|
|
|
|
}))
|
2021-08-30 17:47:21 +00:00
|
|
|
if got > want {
|
|
|
|
t.Errorf("allocs = %v; want %v", got, want)
|
2021-07-06 05:13:33 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-07-27 16:10:22 +00:00
|
|
|
// Test for http://go/corp/6311 issue.
|
|
|
|
func TestHashThroughView(t *testing.T) {
|
|
|
|
type sshPolicyOut struct {
|
|
|
|
Rules []tailcfg.SSHRuleView
|
|
|
|
}
|
|
|
|
type mapResponseOut struct {
|
|
|
|
SSHPolicy *sshPolicyOut
|
|
|
|
}
|
|
|
|
// Just test we don't panic:
|
|
|
|
_ = Hash(&mapResponseOut{
|
|
|
|
SSHPolicy: &sshPolicyOut{
|
|
|
|
Rules: []tailcfg.SSHRuleView{
|
|
|
|
(&tailcfg.SSHRule{
|
|
|
|
RuleExpires: ptrTo(time.Unix(123, 0)),
|
|
|
|
}).View(),
|
|
|
|
},
|
|
|
|
},
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
2021-07-06 05:13:33 +00:00
|
|
|
func BenchmarkHashArray(b *testing.B) {
|
|
|
|
b.ReportAllocs()
|
|
|
|
type T struct {
|
|
|
|
X [32]byte
|
|
|
|
}
|
|
|
|
x := &T{X: [32]byte{1: 1, 2: 2, 3: 3, 4: 4}}
|
|
|
|
|
|
|
|
for i := 0; i < b.N; i++ {
|
|
|
|
sink = Hash(x)
|
|
|
|
}
|
|
|
|
}
|
2022-08-12 00:44:09 +00:00
|
|
|
|
|
|
|
// hashBuffer is a hash.Hash that buffers all written data.
|
|
|
|
type hashBuffer struct {
|
|
|
|
hash.Hash
|
|
|
|
B []byte
|
|
|
|
}
|
|
|
|
|
|
|
|
func (h *hashBuffer) Write(b []byte) (int, error) {
|
|
|
|
n, err := h.Hash.Write(b)
|
|
|
|
h.B = append(h.B, b[:n]...)
|
|
|
|
return n, err
|
|
|
|
}
|
|
|
|
func (h *hashBuffer) Reset() {
|
|
|
|
h.Hash.Reset()
|
|
|
|
h.B = h.B[:0]
|
|
|
|
}
|