Reduce memory footprint by reusing buffers

bson/bson.go

@@ -489,8 +489,15 @@ func handleErr(err *error) {
 //     }
 //
 func Marshal(in interface{}) (out []byte, err error) {
+	return MarshalBuffer(in, make([]byte, 0, initialBufferSize))
+}
+
+// MarshalBuffer behaves the same way as Marshal, except that instead of
+// allocating a new byte slice it tries to use the received byte slice and
+// only allocates more memory if necessary to fit the marshaled value.
+func MarshalBuffer(in interface{}, buf []byte) (out []byte, err error) {
 	defer handleErr(&err)
-	e := &encoder{make([]byte, 0, initialBufferSize)}
+	e := &encoder{buf}
 	e.addDoc(reflect.ValueOf(in))
 	return e.out, nil
 }

bson/bson_test.go

@@ -249,6 +249,13 @@ func (s *S) TestUnmarshalNonNilInterface(c *C) {
 	c.Assert(m, DeepEquals, bson.M{"a": 1})
 }
 
+func (s *S) TestMarshalBuffer(c *C) {
+	buf := make([]byte, 0, 256)
+	data, err := bson.MarshalBuffer(bson.M{"a": 1}, buf)
+	c.Assert(err, IsNil)
+	c.Assert(data, DeepEquals, buf[:len(data)])
+}
+
 // --------------------------------------------------------------------------
 // Some one way marshaling operations which would unmarshal differently.
 

session_test.go

@@ -34,6 +34,7 @@ import (
 	"sort"
 	"strconv"
 	"strings"
+	"testing"
 	"time"
 
 	. "gopkg.in/check.v1"
@@ -4092,3 +4093,46 @@ func (s *S) BenchmarkFindIterRaw(c *C) {
 	c.Assert(iter.Err(), IsNil)
 	c.Assert(i, Equals, c.N)
 }
+
+func BenchmarkInsertSingle(b *testing.B) {
+	session, err := mgo.Dial("localhost:40001")
+	if err != nil {
+		b.Fatal(err)
+	}
+	defer session.Close()
+
+	doc := bson.D{
+		{"A", strings.Repeat("*", 256)},
+	}
+	coll := session.DB("mydb").C("benchmarkcoll")
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		err := coll.Insert(doc)
+		if err != nil {
+			b.Fatal(err)
+		}
+	}
+}
+
+func BenchmarkInsertMultiple(b *testing.B) {
+	session, err := mgo.Dial("localhost:40001")
+	if err != nil {
+		b.Fatal(err)
+	}
+	defer session.Close()
+
+	docs := make([]interface{}, 100)
+	for i := range docs {
+		docs[i] = bson.D{
+			{"A", strings.Repeat("*", 256)},
+		}
+	}
+	coll := session.DB("mydb").C("benchmarkcoll")
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		err := coll.Insert(docs...)
+		if err != nil {
+			b.Fatal(err)
+		}
+	}
+}

socket.go

@@ -372,13 +372,22 @@ func (socket *mongoSocket) SimpleQuery(op *queryOp) (data []byte, err error) {
 	return data, err
 }
 
+var bytesBufferPool = sync.Pool{
+	New: func() interface{} {
+		return make([]byte, 0, 256)
+	},
+}
+
 func (socket *mongoSocket) Query(ops ...interface{}) (err error) {
 
 	if lops := socket.flushLogout(); len(lops) > 0 {
 		ops = append(lops, ops...)
 	}
 
-	buf := make([]byte, 0, 256)
+	buf := bytesBufferPool.Get().([]byte)
+	defer func() {
+		bytesBufferPool.Put(buf[:0])
+	}()
 
 	// Serialize operations synchronously to avoid interrupting
 	// other goroutines while we can't really be sending data.
@@ -674,11 +683,11 @@ func addBSON(b []byte, doc interface{}) ([]byte, error) {
 	if doc == nil {
 		return append(b, 5, 0, 0, 0, 0), nil
 	}
-	data, err := bson.Marshal(doc)
+	data, err := bson.MarshalBuffer(doc, b)
 	if err != nil {
 		return b, err
 	}
-	return append(b, data...), nil
+	return data, nil
 }
 
 func setInt32(b []byte, pos int, i int32) {