Change uint128 from [2]uint64 to a struct of hi/lo to appease compiler

If golang/go#24416 gets fixed we could revert this.

name                              old time/op    new time/op    delta
StdIPv4-4                            361ns ± 9%     386ns ± 8%     ~     (p=0.167 n=5+5)
IPv4-4                               273ns ±12%     301ns ±14%     ~     (p=0.238 n=5+5)
IPv4_inline-4                        251ns ± 5%     262ns ±10%     ~     (p=0.730 n=5+5)
StdIPv6-4                            507ns ±18%     490ns ±13%     ~     (p=0.651 n=5+5)
IPv6-4                               414ns ± 8%     416ns ± 6%     ~     (p=1.000 n=5+5)
IPv4Contains-4                      30.1ns ± 4%    13.1ns ±12%  -56.41%  (p=0.008 n=5+5)
ParseIP/v4-4                        55.9ns ± 5%    49.5ns ±10%  -11.35%  (p=0.032 n=5+5)
ParseIP/v6-4                         244ns ± 9%     217ns ± 8%  -10.76%  (p=0.040 n=5+5)
ParseIP/v6_ellipsis-4                157ns ±12%     157ns ± 7%     ~     (p=0.730 n=5+5)
ParseIP/v6_v4-4                      191ns ±12%     168ns ±19%     ~     (p=0.310 n=5+5)
ParseIP/v6_zone-4                    464ns ±21%     448ns ±12%     ~     (p=0.841 n=5+5)
StdParseIP/v4-4                      186ns ± 5%     186ns ±13%     ~     (p=1.000 n=5+5)
StdParseIP/v6-4                      362ns ± 7%     330ns ± 5%   -8.68%  (p=0.016 n=5+5)
StdParseIP/v6_ellipsis-4             258ns ±17%     280ns ± 6%     ~     (p=0.254 n=5+5)
StdParseIP/v6_v4-4                   427ns ±28%     457ns ±15%     ~     (p=0.548 n=5+5)
StdParseIP/v6_zone-4                 285ns ±17%     305ns ±13%     ~     (p=0.421 n=5+5)
IPString/v4-4                        153ns ±21%     122ns ±17%  -19.79%  (p=0.048 n=5+5)
IPString/v6-4                        356ns ± 3%     345ns ±22%     ~     (p=0.151 n=5+5)
IPString/v6_ellipsis-4               346ns ±13%     329ns ±20%     ~     (p=0.548 n=5+5)
IPString/v6_v4-4                     309ns ±15%     266ns ±11%  -13.90%  (p=0.032 n=5+5)
IPString/v6_zone-4                   362ns ±18%     330ns ±21%     ~     (p=0.421 n=5+5)
IPPrefixMasking/IPv4_/32-4          54.8ns ± 4%    15.1ns ± 4%  -72.44%  (p=0.008 n=5+5)
IPPrefixMasking/IPv4_/17-4          54.9ns ± 4%    14.6ns ± 5%  -73.38%  (p=0.008 n=5+5)
IPPrefixMasking/IPv4_/0-4           55.0ns ± 4%    13.5ns ± 6%  -75.50%  (p=0.008 n=5+5)
IPPrefixMasking/IPv6_/128-4         55.0ns ± 1%    15.5ns ± 7%  -71.79%  (p=0.008 n=5+5)
IPPrefixMasking/IPv6_/65-4          54.2ns ± 2%    14.6ns ± 5%  -73.04%  (p=0.008 n=5+5)
IPPrefixMasking/IPv6_/0-4           55.4ns ± 2%    14.9ns ± 9%  -73.06%  (p=0.008 n=5+5)
IPPrefixMasking/IPv6_zone_/128-4    54.4ns ± 1%    15.0ns ±13%  -72.44%  (p=0.008 n=5+5)
IPPrefixMasking/IPv6_zone_/65-4     55.5ns ± 2%    14.8ns ±16%  -73.31%  (p=0.008 n=5+5)
IPPrefixMasking/IPv6_zone_/0-4      54.8ns ± 4%    14.7ns ± 8%  -73.23%  (p=0.008 n=5+5)
ParseIPPort/v4-4                     118ns ± 8%     103ns ± 9%  -12.88%  (p=0.008 n=5+5)
ParseIPPort/v6-4                     318ns ±12%     262ns ± 6%  -17.38%  (p=0.008 n=5+5)
ParseIPPort/v6_ellipsis-4            243ns ±10%     240ns ±19%     ~     (p=0.841 n=5+5)
ParseIPPort/v6_v4-4                  279ns ±14%     237ns ±16%  -14.91%  (p=0.040 n=5+5)
ParseIPPort/v6_zone-4                578ns ± 9%     546ns ± 7%     ~     (p=0.222 n=5+5)
IPRangePrefix-4                      142ns ± 5%      61ns ±11%  -56.74%  (p=0.008 n=5+5)
IPSetFuzz-4                         41.0µs ±16%    33.3µs ±15%  -18.87%  (p=0.016 n=5+5)

Fixes #102

Signed-off-by: Brad Fitzpatrick <[email protected]>

Author: bradfitz

inlining_test.go

@@ -46,6 +46,7 @@ func TestInlining(t *testing.T) {
 		"(*IPSet).RemoveRange",
 		"(*uint128).clear",
 		"(*uint128).set",
+		"(*uint128).halves",
 		"IP.BitLen",
 		"IP.IPAddr",
 		"IP.Is4",
@@ -58,8 +59,6 @@ func TestInlining(t *testing.T) {
 		"IP.MarshalText",
 		"IP.Unmap",
 		"IP.Zone",
-		"IP.hi",
-		"IP.lo",
 		"IP.v4",
 		"IP.v6",
 		"IP.v6u16",

netaddr.go

@@ -40,17 +40,16 @@ const maxUint16 = 1<<16 - 1
 // Its memory representation is 24 bytes on 64-bit machines (the same
 // size as a Go slice header) for both IPv4 and IPv6 address.
 type IP struct {
-	// addr are the hi (the first uint64) and lo bits (second
-	// uint64) of an IPv6 address. If z==z4, hi and lo contain the
-	// IPv4-mapped IPv6 address.
+	// addr are the hi and lo bits of an IPv6 address. If z==z4,
+	// hi and lo contain the IPv4-mapped IPv6 address.
 	//
 	// hi and lo are constructed by interpreting a 16-byte IPv6
 	// address as a big-endian 128-bit number. The most significant
 	// bits of that number go into hi, the rest into lo.
 	//
 	// For example, 0011:2233:4455:6677:8899:aabb:ccdd:eeff is stored as:
-	//  addr[0] (hi) = 0x0011223344556677
-	//  addr[1] (lo) = 0x8899aabbccddeeff
+	//  addr.hi = 0x0011223344556677
+	//  addr.lo = 0x8899aabbccddeeff
 	//
 	// We store IPs like this, rather than as [16]byte, because it
 	// turns most operations on IPs into arithmetic and bit-twiddling
@@ -68,9 +67,6 @@ type IP struct {
 	z *intern.Value
 }
 
-func (ip IP) hi() uint64 { return ip.addr[0] }
-func (ip IP) lo() uint64 { return ip.addr[1] }
-
 // z0, z4, and z6noz are sentinel IP.z values.
 // See the IP type's field docs.
 var (
@@ -379,17 +375,17 @@ func FromStdIPRaw(std net.IP) (ip IP, ok bool) {
 // v4 returns the i'th byte of ip. If ip is not an IPv4, v4 returns
 // unspecified garbage.
 func (ip IP) v4(i uint8) uint8 {
-	return uint8(ip.lo() >> ((3 - i) * 8))
+	return uint8(ip.addr.lo >> ((3 - i) * 8))
 }
 
 // v6 returns the i'th byte of ip. If ip is an IPv4 address, this
 // accesses the IPv4-mapped IPv6 address form of the IP.
 func (ip IP) v6(i uint8) uint8 {
-	return uint8(ip.addr[(i/8)%2] >> ((7 - i%8) * 8))
+	return uint8(*(ip.addr.halves()[(i/8)%2]) >> ((7 - i%8) * 8))
 }
 
 func (ip IP) v6u16(i uint8) uint16 {
-	return uint16(ip.addr[(i/4)%2] >> ((3 - i%4) * 16))
+	return uint16(*(ip.addr.halves()[(i/4)%2]) >> ((3 - i%4) * 16))
 }
 
 // IsZero reports whether ip is the zero value of the IP type.
@@ -436,12 +432,12 @@ func (ip IP) Compare(ip2 IP) int {
 	if f1 > f2 {
 		return 1
 	}
-	if hi1, hi2 := ip.hi(), ip2.hi(); hi1 < hi2 {
+	if hi1, hi2 := ip.addr.hi, ip2.addr.hi; hi1 < hi2 {
 		return -1
 	} else if hi1 > hi2 {
 		return 1
 	}
-	if lo1, lo2 := ip.lo(), ip2.lo(); lo1 < lo2 {
+	if lo1, lo2 := ip.addr.lo, ip2.addr.lo; lo1 < lo2 {
 		return -1
 	} else if lo1 > lo2 {
 		return 1
@@ -496,7 +492,7 @@ func (ip IP) Is4() bool {
 
 // Is4in6 reports whether ip is an IPv4-mapped IPv6 address.
 func (ip IP) Is4in6() bool {
-	return ip.Is6() && ip.hi() == 0 && ip.lo()>>32 == 0xffff
+	return ip.Is6() && ip.addr.hi == 0 && ip.addr.lo>>32 == 0xffff
 }
 
 // Is6 reports whether ip is an IPv6 address, including IPv4-mapped
@@ -551,7 +547,7 @@ func (ip IP) IsLoopback() bool {
 		return ip.v4(0) == 127
 	}
 	if ip.Is6() {
-		return ip.hi() == 0 && ip.lo() == 1
+		return ip.addr.hi == 0 && ip.addr.lo == 1
 	}
 	return false // zero value
 }
@@ -563,7 +559,7 @@ func (ip IP) IsMulticast() bool {
 		return ip.v4(0)&0xf0 == 0xe0
 	}
 	if ip.Is6() {
-		return ip.v6(0) == 0xff
+		return ip.addr.hi>>(64-8) == 0xff // ip.v6(0) == 0xff
 	}
 	return false // zero value
 }
@@ -598,8 +594,8 @@ func (ip IP) Prefix(bits uint8) (IPPrefix, error) {
 // The ip zero value returns all zeroes.
 func (ip IP) As16() [16]byte {
 	var ret [16]byte
-	binary.BigEndian.PutUint64(ret[:8], ip.hi())
-	binary.BigEndian.PutUint64(ret[8:], ip.lo())
+	binary.BigEndian.PutUint64(ret[:8], ip.addr.hi)
+	binary.BigEndian.PutUint64(ret[8:], ip.addr.lo)
 	return ret
 }
 
@@ -609,7 +605,7 @@ func (ip IP) As16() [16]byte {
 func (ip IP) As4() [4]byte {
 	if ip.z == z4 || ip.Is4in6() {
 		var ret [4]byte
-		binary.BigEndian.PutUint32(ret[:], uint32(ip.lo()))
+		binary.BigEndian.PutUint32(ret[:], uint32(ip.addr.lo))
 		return ret
 	}
 	if ip.z == z0 {
@@ -1074,12 +1070,12 @@ func (p IPPrefix) Contains(ip IP) bool {
 	}
 	if ip.Is4() {
 		m := mask4(p.Bits)
-		return uint32(ip.lo())&m == uint32(p.IP.lo())&m
+		return uint32(ip.addr.lo)&m == uint32(p.IP.addr.lo)&m
 	} else {
 		m := mask6(p.Bits)
 		// TODO: benchmark whether the short circuit below is faster or slower
 		// than the higher level alternative: 'ip.addr.and(m) == p.IP.addr.and(m)'.
-		return ip.hi()&m[0] == p.IP.hi()&m[0] && ip.lo()&m[1] == p.IP.lo()&m[1]
+		return ip.addr.hi&m.hi == p.IP.addr.hi&m.hi && ip.addr.lo&m.lo == p.IP.addr.lo&m.lo
 	}
 }
 
@@ -1273,22 +1269,24 @@ func (r IPRange) Overlaps(o IPRange) bool {
 }
 
 // uint128 represents a uint128 using two uint64s.
-// Index 0 contains the high bits, index 1 contains the low.
-type uint128 [2]uint64
+type uint128 struct {
+	hi uint64
+	lo uint64
+}
 
 // and returns the bitwise AND of u and m (u&m).
 func (u uint128) and(m uint128) uint128 {
-	return uint128{u[0] & m[0], u[1] & m[1]}
+	return uint128{u.hi & m.hi, u.lo & m.lo}
 }
 
 // xor returns the bitwise XOR of u and m (u^m).
 func (u uint128) xor(m uint128) uint128 {
-	return uint128{u[0] ^ m[0], u[1] ^ m[1]}
+	return uint128{u.hi ^ m.hi, u.lo ^ m.lo}
 }
 
 // or returns the bitwise OR of u and m (u|m).
 func (u uint128) or(m uint128) uint128 {
-	return uint128{u[0] | m[0], u[1] | m[1]}
+	return uint128{u.hi | m.hi, u.lo | m.lo}
 }
 
 func u64CommonPrefixLen(a, b uint64) uint8 {
@@ -1303,22 +1301,26 @@ func u64CommonPrefixLen(a, b uint64) uint8 {
 }
 
 func (a uint128) commonPrefixLen(b uint128) (n uint8) {
-	if n = u64CommonPrefixLen(a[0], b[0]); n == 64 {
-		n += u64CommonPrefixLen(a[1], b[1])
+	if n = u64CommonPrefixLen(a.hi, b.hi); n == 64 {
+		n += u64CommonPrefixLen(a.lo, b.lo)
 	}
 	return
 }
 
+func (u *uint128) halves() [2]*uint64 {
+	return [2]*uint64{&u.hi, &u.lo}
+}
+
 func (u *uint128) set(bit uint8) {
 	hli := (bit / 64) % 2 // hi/lo index: 0 or 1, respectively
 	s := 63 - (bit % 64)
-	u[hli] |= 1 << s
+	*(u.halves()[hli]) |= 1 << s
 }
 
 func (u *uint128) clear(bit uint8) {
 	hli := (bit / 64) % 2 // hi/lo index: 0 or 1, respectively
 	s := 63 - (bit % 64)
-	u[hli] &^= 1 << s
+	*(u.halves()[hli]) &^= 1 << s
 }
 
 // lastWithBitZero returns a copy of u with the given bit

netaddr_test.go

@@ -2716,15 +2716,15 @@ func TestPointLess(t *testing.T) {
 func (u uint128) bitSet(bit uint8) bool {
 	hli := (bit / 64) % 2 // hi/lo index: 0 or 1, respectively
 	s := 63 - (bit % 64)
-	return u[hli]&(1<<s) != 0
+	return *(u.halves()[hli])&(1<<s) != 0
 }
 
 func TestUint128(t *testing.T) {
 	randU128 := func() (uint128, string) {
 		var a [16]byte
 		rand.Read(a[:])
 		u := ipv6Slice(a[:]).addr
-		return u, fmt.Sprintf("%064b%064b", u[0], u[1])
+		return u, fmt.Sprintf("%064b%064b", u.hi, u.lo)
 	}
 
 	u128, bitStr := randU128()