reduce allocations in Bytes() and manet methods (#280)

Old:
```
goos: darwin
goarch: arm64
pkg: github.com/multiformats/go-multiaddr/net
cpu: Apple M1
BenchmarkResolveUnspecifiedAddress
BenchmarkResolveUnspecifiedAddress-8     2568914               477.7 ns/op           992 B/op         13 allocs/op
PASS
ok      github.com/multiformats/go-multiaddr/net        2.794s
```

New:
```
goos: darwin
goarch: arm64
pkg: github.com/multiformats/go-multiaddr/net
cpu: Apple M1
BenchmarkResolveUnspecifiedAddress
BenchmarkResolveUnspecifiedAddress-8     9361288               127.2 ns/op           240 B/op          3 allocs/op
PASS
ok      github.com/multiformats/go-multiaddr/net        3.316s
```

Author: sukunrt

component.go

@@ -163,10 +163,10 @@ func (c *Component) Protocol() Protocol {
 }
 
 func (c *Component) Code() int {
-	if c == nil {
+	if c == nil || c.protocol == nil {
 		return 0
 	}
-	return c.Protocol().Code
+	return c.protocol.Code
 }
 
 func (c *Component) RawValue() []byte {

multiaddr.go

@@ -91,11 +91,18 @@ func (m Multiaddr) Bytes() []byte {
 		size += len(c.bytes)
 	}
 
-	out := make([]byte, 0, size)
+	// This method is inlined in the caller. Using a fixed sized array
+	// avoids an allocation.
+	var out []byte
+	if size < 128 {
+		var o [128]byte
+		out = o[:0]
+	} else {
+		out = make([]byte, 0, size)
+	}
 	for _, c := range m {
 		out = append(out, c.bytes...)
 	}
-
 	return out
 }
 

multiaddr_test.go

@@ -1255,3 +1255,16 @@ func FuzzComponents(f *testing.F) {
 		}
 	})
 }
+
+func BenchmarkBytes(b *testing.B) {
+	addr := StringCast("/ip4/127.0.0.1/tcp/1234")
+	b.ReportAllocs()
+	b.ResetTimer()
+	m := make(map[string]Multiaddr)
+	for i := 0; i < b.N; i++ {
+		_ = addr.Bytes()
+		if _, ok := m[string(addr.Bytes())]; !ok {
+			m["a"] = addr
+		}
+	}
+}

net/ip.go

@@ -63,13 +63,13 @@ func IsIPLoopback(m ma.Multiaddr) bool {
 	if m == nil {
 		return false
 	}
-	c, _ := ma.SplitFirst(m)
-	if c == nil {
+	head, _ := splitFirstSlice(m)
+	if len(head) == 0 {
 		return false
 	}
-	switch c.Protocol().Code {
+	switch head[0].Code() {
 	case ma.P_IP4, ma.P_IP6:
-		return net.IP(c.RawValue()).IsLoopback()
+		return net.IP(head[0].RawValue()).IsLoopback()
 	}
 	return false
 }
@@ -82,39 +82,52 @@ func IsIP6LinkLocal(m ma.Multiaddr) bool {
 	if m == nil {
 		return false
 	}
-	c, _ := ma.SplitFirst(m)
-	if c == nil || c.Protocol().Code != ma.P_IP6 {
+	head, _ := splitFirstSlice(m)
+	if len(head) == 0 || head[0].Code() != ma.P_IP6 {
 		return false
 	}
-	ip := net.IP(c.RawValue())
+	ip := net.IP(head[0].RawValue())
 	return ip.IsLinkLocalMulticast() || ip.IsLinkLocalUnicast()
 }
 
 // IsIPUnspecified returns whether a Multiaddr starts with an Unspecified IP address
 // This means either /ip4/0.0.0.0/* or /ip6/::/*
 func IsIPUnspecified(m ma.Multiaddr) bool {
 	m = zoneless(m)
-	if m == nil {
+	if len(m) == 0 {
+		return false
+	}
+	head, _ := splitFirstSlice(m)
+	if len(head) == 0 {
 		return false
 	}
-	c, _ := ma.SplitFirst(m)
-	return net.IP(c.RawValue()).IsUnspecified()
+	return net.IP(head[0].RawValue()).IsUnspecified()
+}
+
+func splitFirstSlice(m ma.Multiaddr) (ma.Multiaddr, ma.Multiaddr) {
+	switch len(m) {
+	case 0:
+		return nil, nil
+	case 1:
+		return m, nil
+	default:
+		return m[:1], m[1:]
+	}
 }
 
 // If m matches [zone,ip6,...], return [ip6,...]
 // else if m matches [], [zone], or [zone,...], return nil
 // else return m
 func zoneless(m ma.Multiaddr) ma.Multiaddr {
-	head, tail := ma.SplitFirst(m)
-	if head == nil {
+	head, tail := splitFirstSlice(m)
+	if len(head) == 0 {
 		return nil
 	}
-	if head.Protocol().Code == ma.P_IP6ZONE {
-		if tail == nil {
+	if head[0].Code() == ma.P_IP6ZONE {
+		if len(tail) == 0 {
 			return nil
 		}
-		tailhead, _ := ma.SplitFirst(tail)
-		if tailhead.Protocol().Code != ma.P_IP6 {
+		if tail[0].Code() != ma.P_IP6 {
 			return nil
 		}
 		return tail
@@ -126,7 +139,7 @@ func zoneless(m ma.Multiaddr) ma.Multiaddr {
 // IsNAT64IPv4ConvertedIPv6Addr returns whether addr is a well-known prefix "64:ff9b::/96" addr
 // used for NAT64 Translation. See RFC 6052
 func IsNAT64IPv4ConvertedIPv6Addr(addr ma.Multiaddr) bool {
-	c, _ := ma.SplitFirst(addr)
-	return c != nil && c.Protocol().Code == ma.P_IP6 &&
-		inAddrRange(c.RawValue(), nat64)
+	head, _ := splitFirstSlice(addr)
+	return len(head) > 0 && head[0].Code() == ma.P_IP6 &&
+		inAddrRange(head[0].RawValue(), nat64)
 }

net/net_test.go

@@ -684,9 +684,13 @@ func TestNetListener(t *testing.T) {
 }
 
 func BenchmarkResolveUnspecifiedAddress(b *testing.B) {
-	b.ReportAllocs()
 	a := ma.StringCast("/ip4/0.0.0.0/udp/42/quic-v1")
-	iaddrs, _ := interfaceAddresses()
+	iaddrs := []ma.Multiaddr{
+		ma.StringCast("/ip4/127.0.0.1/udp/42/quic-v1"),
+		ma.StringCast("/ip4/192.168.1.1/udp/42/quic-v1"),
+	}
+	b.ReportAllocs()
+	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
 		ResolveUnspecifiedAddress(a, iaddrs)
 	}

net/resolve.go

@@ -7,29 +7,30 @@ import (
 )
 
 // ResolveUnspecifiedAddress expands an unspecified ip addresses (/ip4/0.0.0.0, /ip6/::) to
-// use the known local interfaces. If ifaceAddr is nil, we request interface addresses
-// from the network stack. (this is so you can provide a cached value if resolving many addrs)
+// use the known local interfaces.
 func ResolveUnspecifiedAddress(resolve ma.Multiaddr, ifaceAddrs []ma.Multiaddr) ([]ma.Multiaddr, error) {
 	// split address into its components
-	first, rest := ma.SplitFirst(resolve)
+	first, rest := splitFirstSlice(resolve)
 
 	// if first component (ip) is not unspecified, use it as is.
-	if !IsIPUnspecified(first.Multiaddr()) {
+	if !IsIPUnspecified(first) {
 		return []ma.Multiaddr{resolve}, nil
 	}
 
-	resolveProto := resolve.Protocols()[0].Code
+	resolveProto := first[0].Code()
 	out := make([]ma.Multiaddr, 0, len(ifaceAddrs))
 	for _, ia := range ifaceAddrs {
-		iafirst, _ := ma.SplitFirst(ia)
+		iafirst, _ := splitFirstSlice(ia)
 		// must match the first protocol to be resolve.
-		if iafirst.Protocol().Code != resolveProto {
+		if len(iafirst) == 0 || iafirst[0].Code() != resolveProto {
 			continue
 		}
 
 		joined := ia
-		if rest != nil {
-			joined = ma.Join(ia, rest)
+		if len(rest) > 0 {
+			joined = make(ma.Multiaddr, 0, len(iafirst)+len(rest))
+			joined = append(joined, iafirst...)
+			joined = append(joined, rest...)
 		}
 		out = append(out, joined)
 	}