Memory usage optimizations

protocol/marshal.go

@@ -21,6 +21,7 @@ type marshalWriter struct {
 	w   io.Writer
 	tot int
 	err error
+	b   [8]byte
 }
 
 // We will never encode nor expect to decode blobs larger than 10 MB. Check
@@ -57,12 +58,11 @@ func (w *marshalWriter) writeUint32(v uint32) {
 	if w.err != nil {
 		return
 	}
-	var b [4]byte
-	b[0] = byte(v >> 24)
-	b[1] = byte(v >> 16)
-	b[2] = byte(v >> 8)
-	b[3] = byte(v)
-	_, w.err = w.w.Write(b[:])
+	w.b[0] = byte(v >> 24)
+	w.b[1] = byte(v >> 16)
+	w.b[2] = byte(v >> 8)
+	w.b[3] = byte(v)
+	_, w.err = w.w.Write(w.b[:4])
 	w.tot += 4
 }
 
@@ -70,16 +70,15 @@ func (w *marshalWriter) writeUint64(v uint64) {
 	if w.err != nil {
 		return
 	}
-	var b [8]byte
-	b[0] = byte(v >> 56)
-	b[1] = byte(v >> 48)
-	b[2] = byte(v >> 40)
-	b[3] = byte(v >> 32)
-	b[4] = byte(v >> 24)
-	b[5] = byte(v >> 16)
-	b[6] = byte(v >> 8)
-	b[7] = byte(v)
-	_, w.err = w.w.Write(b[:])
+	w.b[0] = byte(v >> 56)
+	w.b[1] = byte(v >> 48)
+	w.b[2] = byte(v >> 40)
+	w.b[3] = byte(v >> 32)
+	w.b[4] = byte(v >> 24)
+	w.b[5] = byte(v >> 16)
+	w.b[6] = byte(v >> 8)
+	w.b[7] = byte(v)
+	_, w.err = w.w.Write(w.b[:8])
 	w.tot += 8
 }
 
@@ -87,6 +86,7 @@ type marshalReader struct {
 	r   io.Reader
 	tot int
 	err error
+	b   [8]byte
 }
 
 func (r *marshalReader) readString() string {
@@ -117,19 +117,17 @@ func (r *marshalReader) readUint32() uint32 {
 	if r.err != nil {
 		return 0
 	}
-	var b [4]byte
-	_, r.err = io.ReadFull(r.r, b[:])
+	_, r.err = io.ReadFull(r.r, r.b[:4])
 	r.tot += 4
-	return uint32(b[3]) | uint32(b[2])<<8 | uint32(b[1])<<16 | uint32(b[0])<<24
+	return uint32(r.b[3]) | uint32(r.b[2])<<8 | uint32(r.b[1])<<16 | uint32(r.b[0])<<24
 }
 
 func (r *marshalReader) readUint64() uint64 {
 	if r.err != nil {
 		return 0
 	}
-	var b [8]byte
-	_, r.err = io.ReadFull(r.r, b[:])
+	_, r.err = io.ReadFull(r.r, r.b[:8])
 	r.tot += 8
-	return uint64(b[7]) | uint64(b[6])<<8 | uint64(b[5])<<16 | uint64(b[4])<<24 |
-		uint64(b[3])<<32 | uint64(b[2])<<40 | uint64(b[1])<<48 | uint64(b[0])<<56
+	return uint64(r.b[7]) | uint64(r.b[6])<<8 | uint64(r.b[5])<<16 | uint64(r.b[4])<<24 |
+		uint64(r.b[3])<<32 | uint64(r.b[2])<<40 | uint64(r.b[1])<<48 | uint64(r.b[0])<<56
 }

protocol/messages.go

@@ -48,7 +48,7 @@ func (w *marshalWriter) writeIndex(idx []FileInfo) {
 }
 
 func WriteIndex(w io.Writer, idx []FileInfo) (int, error) {
-	mw := marshalWriter{w, 0, nil}
+	mw := marshalWriter{w: w}
 	mw.writeIndex(idx)
 	return mw.tot, mw.err
 }
@@ -90,7 +90,7 @@ func (r *marshalReader) readIndex() []FileInfo {
 }
 
 func ReadIndex(r io.Reader) ([]FileInfo, error) {
-	mr := marshalReader{r, 0, nil}
+	mr := marshalReader{r: r}
 	idx := mr.readIndex()
 	return idx, mr.err
 }

protocol/protocol.go

@@ -57,7 +57,7 @@ type Connection struct {
 	lastReceive    time.Time
 	peerLatency    time.Duration
 	lastStatistics Statistics
-	lastIndexSent  map[string]FileInfo
+	indexSent      map[string]int64
 }
 
 var ErrClosed = errors.New("Connection closed")
@@ -80,9 +80,9 @@ func NewConnection(nodeID string, reader io.Reader, writer io.Writer, receiver M
 	c := Connection{
 		receiver:       receiver,
 		reader:         flrd,
-		mreader:        &marshalReader{flrd, 0, nil},
+		mreader:        &marshalReader{r: flrd},
 		writer:         flwr,
-		mwriter:        &marshalWriter{flwr, 0, nil},
+		mwriter:        &marshalWriter{w: flwr},
 		awaiting:       make(map[int]chan asyncResult),
 		lastReceive:    time.Now(),
 		ID:             nodeID,
@@ -100,22 +100,22 @@ func (c *Connection) Index(idx []FileInfo) {
 	c.Lock()
 
 	var msgType int
-	if c.lastIndexSent == nil {
+	if c.indexSent == nil {
 		// This is the first time we send an index.
 		msgType = messageTypeIndex
 
-		c.lastIndexSent = make(map[string]FileInfo)
+		c.indexSent = make(map[string]int64)
 		for _, f := range idx {
-			c.lastIndexSent[f.Name] = f
+			c.indexSent[f.Name] = f.Modified
 		}
 	} else {
 		// We have sent one full index. Only send updates now.
 		msgType = messageTypeIndexUpdate
 		var diff []FileInfo
 		for _, f := range idx {
-			if ef, ok := c.lastIndexSent[f.Name]; !ok || ef.Modified != f.Modified {
+			if modified, ok := c.indexSent[f.Name]; !ok || f.Modified != modified {
 				diff = append(diff, f)
-				c.lastIndexSent[f.Name] = f
+				c.indexSent[f.Name] = f.Modified
 			}
 		}
 		idx = diff