conn: remove the final alloc per packet receive

This does bind_std only; other platforms remain.

The remaining alloc per iteration in the Throughput benchmark
comes from the tuntest package, and should not appear in regular use.

name           old time/op      new time/op      delta
Latency-10         25.2µs ± 1%      25.0µs ± 0%   -0.58%  (p=0.006 n=10+10)
Throughput-10      2.44µs ± 3%      2.41µs ± 2%     ~     (p=0.140 n=10+8)

name           old alloc/op     new alloc/op     delta
Latency-10           854B ± 5%        741B ± 3%  -13.22%  (p=0.000 n=10+10)
Throughput-10        265B ±34%        267B ±39%     ~     (p=0.670 n=10+10)

name           old allocs/op    new allocs/op    delta
Latency-10           16.0 ± 0%        14.0 ± 0%  -12.50%  (p=0.000 n=10+10)
Throughput-10        2.00 ± 0%        1.00 ± 0%  -50.00%  (p=0.000 n=10+10)

name           old packet-loss  new packet-loss  delta
Throughput-10        0.01 ±82%       0.01 ±282%     ~     (p=0.321 n=9+8)

Signed-off-by: Josh Bleecher Snyder <josh@tailscale.com>
Signed-off-by: Jason A. Donenfeld <Jason@zx2c4.com>

diff --git a/conn/bind_std.go b/conn/bind_std.go
index e0f6cdddb5428bb4b7351725f3dc056db3f8597f..b6a7ab32aadaa828fd0d33a7156a683654868b8a 100644 (file)
--- a/conn/bind_std.go
+++ b/conn/bind_std.go
@@ -31,34 +31,34 @@ type StdNetEndpoint netip.AddrPort
 
 var (
        _ Bind     = (*StdNetBind)(nil)
-       _ Endpoint = (*StdNetEndpoint)(nil)
+       _ Endpoint = StdNetEndpoint{}
 )
 
 func (*StdNetBind) ParseEndpoint(s string) (Endpoint, error) {
        e, err := netip.ParseAddrPort(s)
-       return (*StdNetEndpoint)(&e), err
+       return asEndpoint(e), err
 }
 
-func (*StdNetEndpoint) ClearSrc() {}
+func (StdNetEndpoint) ClearSrc() {}
 
-func (e *StdNetEndpoint) DstIP() netip.Addr {
-       return (*netip.AddrPort)(e).Addr()
+func (e StdNetEndpoint) DstIP() netip.Addr {
+       return (netip.AddrPort)(e).Addr()
 }
 
-func (e *StdNetEndpoint) SrcIP() netip.Addr {
+func (e StdNetEndpoint) SrcIP() netip.Addr {
        return netip.Addr{} // not supported
 }
 
-func (e *StdNetEndpoint) DstToBytes() []byte {
-       b, _ := (*netip.AddrPort)(e).MarshalBinary()
+func (e StdNetEndpoint) DstToBytes() []byte {
+       b, _ := (netip.AddrPort)(e).MarshalBinary()
        return b
 }
 
-func (e *StdNetEndpoint) DstToString() string {
-       return (*netip.AddrPort)(e).String()
+func (e StdNetEndpoint) DstToString() string {
+       return (netip.AddrPort)(e).String()
 }
 
-func (e *StdNetEndpoint) SrcToString() string {
+func (e StdNetEndpoint) SrcToString() string {
        return ""
 }
 
@@ -152,24 +152,24 @@ func (bind *StdNetBind) Close() error {
 func (*StdNetBind) makeReceiveIPv4(conn *net.UDPConn) ReceiveFunc {
        return func(buff []byte) (int, Endpoint, error) {
                n, endpoint, err := conn.ReadFromUDPAddrPort(buff)
-               return n, (*StdNetEndpoint)(&endpoint), err
+               return n, asEndpoint(endpoint), err
        }
 }
 
 func (*StdNetBind) makeReceiveIPv6(conn *net.UDPConn) ReceiveFunc {
        return func(buff []byte) (int, Endpoint, error) {
                n, endpoint, err := conn.ReadFromUDPAddrPort(buff)
-               return n, (*StdNetEndpoint)(&endpoint), err
+               return n, asEndpoint(endpoint), err
        }
 }
 
 func (bind *StdNetBind) Send(buff []byte, endpoint Endpoint) error {
        var err error
-       nend, ok := endpoint.(*StdNetEndpoint)
+       nend, ok := endpoint.(StdNetEndpoint)
        if !ok {
                return ErrWrongEndpointType
        }
-       addrPort := (*netip.AddrPort)(nend)
+       addrPort := netip.AddrPort(nend)
 
        bind.mu.Lock()
        blackhole := bind.blackhole4
@@ -186,6 +186,27 @@ func (bind *StdNetBind) Send(buff []byte, endpoint Endpoint) error {
        if conn == nil {
                return syscall.EAFNOSUPPORT
        }
-       _, err = conn.WriteToUDPAddrPort(buff, *addrPort)
+       _, err = conn.WriteToUDPAddrPort(buff, addrPort)
        return err
 }
+
+// endpointPool contains a re-usable set of mapping from netip.AddrPort to Endpoint.
+// This exists to reduce allocations: Putting a netip.AddrPort in an Endpoint allocates,
+// but Endpoints are immutable, so we can re-use them.
+var endpointPool = sync.Pool{
+       New: func() any {
+               return make(map[netip.AddrPort]Endpoint)
+       },
+}
+
+// asEndpoint returns an Endpoint containing ap.
+func asEndpoint(ap netip.AddrPort) Endpoint {
+       m := endpointPool.Get().(map[netip.AddrPort]Endpoint)
+       defer endpointPool.Put(m)
+       e, ok := m[ap]
+       if !ok {
+               e = Endpoint(StdNetEndpoint(ap))
+               m[ap] = e
+       }
+       return e
+}