Write zeros in small chunks rather than all at once.

License: MIT
Signed-off-by: Kevin Atkinson <k@kevina.org>

unixfs/io/sizeadj.go

@@ -79,15 +79,32 @@ func (r *sizeAdjReadSeekCloser) WriteTo(w io.Writer) (int64, error) {
 		return n, err
 	}
 	if r.offset+n < r.size {
-		zeros := make([]byte, r.size-(r.offset+n))
-		n0, err0 := w.Write(zeros)
-		n += int64(n0)
+		n0, err0 := writeZeros(w, r.size-(r.offset+n))
+		n += n0
 		err = err0
 	}
 	r.offset += n
 	return n, err
 }
 
+func writeZeros(w io.Writer, numZeros int64) (int64, error) {
+	n := int64(0)
+	for numZeros > 0 {
+		l := int64(4 * 1024)
+		if l > numZeros {
+			l = numZeros
+		}
+		zeros := make([]byte, l)
+		n0, err := w.Write(zeros)
+		n += int64(n0)
+		if err != nil {
+			return n, err
+		}
+		numZeros -= l
+	}
+	return n, nil
+}
+
 // truncWriter accepts all bytes written to it, but discards the tail
 // after size bytes are accepted
 type truncWriter struct {

unixfs/io/sizeadj_test.go

@@ -105,3 +105,26 @@ func TestTruncWriter(t *testing.T) {
 		t.Fatalf("truncWriter wrote incorrect number of bytes (expected 45): %d", len(res))
 	}
 }
+
+func TestWriteZeros(t *testing.T) {
+	buf := new(bytes.Buffer)
+
+	n, err := writeZeros(buf, 1000)
+	if err != nil {
+		t.Fatalf("writeZeros failed: %v", err)
+	}
+	res := buf.Bytes()
+	if n != 1000 || len(res) != 1000 {
+		t.Fatalf("writeZeros wrote incorrect number of bytes (expected 1000): %d %d", n, len(res))
+	}
+
+	buf.Reset()
+	n, err = writeZeros(buf, 10000)
+	if err != nil {
+		t.Fatalf("writeZeros failed: %v", err)
+	}
+	res = buf.Bytes()
+	if n != 10000 || len(res) != 10000 {
+		t.Fatalf("writeZeros wrote incorrect number of bytes (expected 10000): %d %d", n, len(res))
+	}
+}