gen: optimize unconstrained byte array serialization

gen/decl.go

@@ -249,6 +249,30 @@ func (g *generator) parseIntType(lhs string, t *ast.IntType) {
 }
 
 func (g *generator) parseArray(lhs string, base ast.Type, s ast.LengthConstraint) {
+	if unconstrainedByteType(base) {
+		switch s := s.(type) {
+		case *ast.IntegerConstRef, *ast.IntegerLiteral:
+			size := g.integer(s)
+			g.lengthCheck(size)
+			g.printf("copy(%s[:], %s[:%s])\n", lhs, g.data, size)
+			g.printf("%s = %s[%s:]\n", g.data, g.data, size)
+			return
+		case *ast.IDRef:
+			ref := g.ref(s)
+			g.printf("if uint64(%s) > uint64(len(%s)) { return nil, errors.New(\"data too short\") }\n", ref, g.data)
+			size := fmt.Sprintf("int(%s)", ref)
+			g.printf("%s = make([]%s, %s)\n", lhs, g.tipe(base), size)
+			g.printf("copy(%s, %s[:%s])\n", lhs, g.data, size)
+			g.printf("%s = %s[%s:]\n", g.data, g.data, size)
+			return
+		case nil:
+			g.printf("%s = make([]%s, len(%s))\n", lhs, g.tipe(base), g.data)
+			g.printf("copy(%s, %s)\n", lhs, g.data)
+			g.printf("%s = %s[len(%s):]\n", g.data, g.data, g.data)
+			return
+		}
+	}
+
 	switch s := s.(type) {
 	case *ast.IntegerConstRef, *ast.IntegerLiteral:
 		g.printf("for idx := 0; idx < %s; idx++ {\n", g.integer(s))
@@ -382,6 +406,19 @@ func elementByteSize(base ast.Type) int {
 	}
 }
 
+// unconstrainedByteType reports whether base can be copied without skipping
+// per-element validation.
+func unconstrainedByteType(base ast.Type) bool {
+	switch t := base.(type) {
+	case *ast.IntType:
+		return t.Size == 8 && t.Constraint == nil
+	case *ast.CharType:
+		return true
+	default:
+		return false
+	}
+}
+
 func (g *generator) integer(i ast.Integer) string {
 	x, err := g.resolver.Integer(i)
 	if err != nil {
@@ -537,6 +574,16 @@ func (g *generator) encodeIntType(rhs string, t *ast.IntType) {
 }
 
 func (g *generator) encodeArray(rhs string, base ast.Type, s ast.LengthConstraint) {
+	if unconstrainedByteType(base) {
+		switch s.(type) {
+		case *ast.IntegerConstRef, *ast.IntegerLiteral:
+			g.printf("%s = append(%s, %s[:]...)\n", g.data, g.data, rhs)
+		default:
+			g.printf("%s = append(%s, %s...)\n", g.data, g.data, rhs)
+		}
+		return
+	}
+
 	switch s := s.(type) {
 	case *ast.IntegerConstRef, *ast.IntegerLiteral:
 		g.printf("for idx := 0; idx < %s; idx++ {\n", g.integer(s))
@@ -662,6 +709,10 @@ func (g *generator) validateArray(rhs string, base ast.Type, s ast.LengthConstra
 		panic(unexpected(s))
 	}
 
+	if unconstrainedByteType(base) {
+		return
+	}
+
 	// Validate array elements
 	g.printf("for idx := 0; idx < len(%s); idx++ {\n", rhs)
 	g.validateType(rhs+"[idx]", base)

gen/tests/rem/benchmark_test.go

@@ -0,0 +1,27 @@
+package rem
+
+import "testing"
+
+func BenchmarkParseByteTail(b *testing.B) {
+	data := make([]byte, 4+64*1024)
+	b.SetBytes(int64(len(data)))
+	b.ReportAllocs()
+	b.ResetTimer()
+	for range b.N {
+		if _, err := ParseRem(data); err != nil {
+			b.Fatal(err)
+		}
+	}
+}
+
+func BenchmarkMarshalByteTail(b *testing.B) {
+	message := &Rem{Tail: make([]byte, 64*1024)}
+	b.SetBytes(int64(4 + len(message.Tail)))
+	b.ReportAllocs()
+	b.ResetTimer()
+	for range b.N {
+		if _, err := message.MarshalBinary(); err != nil {
+			b.Fatal(err)
+		}
+	}
+}

gen/tests/rem/rem_test.go

@@ -54,3 +54,12 @@ func TestRemParseSuccess(t *testing.T) {
 		Tail: []byte("thetail"),
 	}, r)
 }
+
+func TestRemParseCopiesTail(t *testing.T) {
+	b := []byte{0, 1, 2, 3, 4, 5, 6}
+	r, err := ParseRem(b)
+	require.NoError(t, err)
+
+	b[4] = 99
+	assert.Equal(t, []byte{4, 5, 6}, r.Tail)
+}