wire: only borrow/return binaryFreeList buffers at the message level

wire/bench_test.go

@@ -326,6 +326,28 @@ func BenchmarkReadOutPoint(b *testing.B) {
 	}
 }
 
+// BenchmarkReadOutPointBuf performs a benchmark on how long it takes to read a
+// transaction output point.
+func BenchmarkReadOutPointBuf(b *testing.B) {
+	b.ReportAllocs()
+
+	buffer := binarySerializer.Borrow()
+	buf := []byte{
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Previous output hash
+		0xff, 0xff, 0xff, 0xff, // Previous output index
+	}
+	r := bytes.NewReader(buf)
+	var op OutPoint
+	for i := 0; i < b.N; i++ {
+		r.Seek(0, 0)
+		readOutPointBuf(r, 0, 0, &op, buffer)
+	}
+	binarySerializer.Return(buffer)
+}
+
 // BenchmarkWriteOutPoint performs a benchmark on how long it takes to write a
 // transaction output point.
 func BenchmarkWriteOutPoint(b *testing.B) {
@@ -340,6 +362,22 @@ func BenchmarkWriteOutPoint(b *testing.B) {
 	}
 }
 
+// BenchmarkWriteOutPointBuf performs a benchmark on how long it takes to write a
+// transaction output point.
+func BenchmarkWriteOutPointBuf(b *testing.B) {
+	b.ReportAllocs()
+
+	buf := binarySerializer.Borrow()
+	op := &OutPoint{
+		Hash:  chainhash.Hash{},
+		Index: 0,
+	}
+	for i := 0; i < b.N; i++ {
+		writeOutPointBuf(ioutil.Discard, 0, 0, op, buf)
+	}
+	binarySerializer.Return(buf)
+}
+
 // BenchmarkReadTxOut performs a benchmark on how long it takes to read a
 // transaction output.
 func BenchmarkReadTxOut(b *testing.B) {

wire/msgtx.go

@@ -968,25 +968,66 @@ func NewMsgTx(version int32) *MsgTx {
 }
 
 // readOutPoint reads the next sequence of bytes from r as an OutPoint.
+//
+// DEPRECATED: Use readOutPointBuf instead.
 func readOutPoint(r io.Reader, pver uint32, version int32, op *OutPoint) error {
+	buf := binarySerializer.Borrow()
+	err := readOutPointBuf(r, pver, version, op, buf)
+	binarySerializer.Return(buf)
+	return err
+}
+
+// readOutPointBuf reads the next sequence of bytes from r as an OutPoint.
+//
+// If b is non-nil, the provided buffer will be used for serializing small
+// values.  Otherwise a buffer will be drawn from the binarySerializer's pool
+// and return when the method finishes.
+//
+// NOTE: b MUST either be nil or at least an 8-byte slice.
+func readOutPointBuf(r io.Reader, pver uint32, version int32, op *OutPoint,
+	buf []byte) error {
+
 	_, err := io.ReadFull(r, op.Hash[:])
 	if err != nil {
 		return err
 	}
 
-	op.Index, err = binarySerializer.Uint32(r, littleEndian)
+	if _, err := io.ReadFull(r, buf[:4]); err != nil {
+		return err
+	}
+	op.Index = littleEndian.Uint32(buf[:4])
+
+	return nil
+}
+
+// WriteOutPoint encodes op to the bitcoin protocol encoding for an OutPoint to
+// w.
+func WriteOutPoint(w io.Writer, pver uint32, version int32, op *OutPoint) error {
+	buf := binarySerializer.Borrow()
+	err := writeOutPointBuf(w, pver, version, op, buf)
+	binarySerializer.Return(buf)
 	return err
 }
 
-// WriteOutPoint encodes op to the bitcoin protocol encoding for an OutPoint
+// writeOutPointBuf encodes op to the bitcoin protocol encoding for an OutPoint
 // to w.
-func WriteOutPoint(w io.Writer, pver uint32, version int32, op *OutPoint) error {
+//
+// If b is non-nil, the provided buffer will be used for serializing small
+// values.  Otherwise a buffer will be drawn from the binarySerializer's pool
+// and return when the method finishes.
+//
+// NOTE: b MUST either be nil or at least an 8-byte slice.
+func writeOutPointBuf(w io.Writer, pver uint32, version int32, op *OutPoint,
+	buf []byte) error {
+
 	_, err := w.Write(op.Hash[:])
 	if err != nil {
 		return err
 	}
 
-	return binarySerializer.PutUint32(w, littleEndian, op.Index)
+	littleEndian.PutUint32(buf[:4], op.Index)
+	_, err = w.Write(buf[:4])
+	return err
 }
 
 // readScript reads a variable length byte array that represents a transaction