fix append memory allocations

Old implementation was focusing on having full control over capacity growth. This caused enormous memory allocations: 1.6GB to load 1.3MB sample. This fix uses built-in append function to grow slice capacity.

Author: dudk

signal.go

@@ -4,6 +4,7 @@ package signal
 
 import (
 	"math"
+	"reflect"
 	"time"
 )
 
@@ -624,3 +625,9 @@ func ReadStripedUint(src Unsigned, dst [][]uint) (read int) {
 	}
 	return
 }
+
+// alignCapacity ensures that buffer capacity is aligned with number of
+// channels.
+func alignCapacity(s interface{}, channels, cap int) {
+	reflect.ValueOf(s).Elem().SetCap(cap - cap%channels)
+}

templates/signal.tmpl

@@ -60,22 +60,23 @@ func (s {{ .Name }}) Sample(i int) {{ .SampleType }} {
 	return {{ .SampleType }}(s.buffer[i])
 }
 
-// Append appends [0:Length] samples from src to current buffer and returns new
-// {{ .Interface }} buffer. Both buffers must have same number of channels and bit depth,
-// otherwise function will panic. If current buffer doesn't have enough capacity,
-// new buffer will be allocated with capacity of both sources.
+// Append appends [0:Length] samples from src to current buffer and returns
+// new {{ .Interface }} buffer. Both buffers must have same number of channels and
+// bit depth, otherwise function will panic.
 func (s {{ .Name }}) Append(src {{ .Interface }}) {{ .Interface }} {
 	mustSameChannels(s.Channels(), src.Channels()){{if ne .Interface "Floating"}}
 	mustSameBitDepth(s.BitDepth(), src.BitDepth()){{end}}
+	offset := s.Len()
 	if s.Cap() < s.Len()+src.Len() {
-		// allocate and append buffer with cap of both sources capacity;
-		s.buffer = append(make([]{{ .Builtin }}, 0, s.Cap()+src.Cap()), s.buffer...)
+		s.buffer = append(s.buffer, make([]{{ .Builtin }}, src.Len())...)
+	} else {
+		s.buffer = s.buffer[:s.Len()+src.Len()]
 	}
-	result := {{ .Interface }}(s)
 	for i := 0; i < src.Len(); i++ {
-		result = result.AppendSample(src.Sample(i))
+		s.SetSample(i+offset, src.Sample(i))
 	}
-	return result
+	alignCapacity(&s.buffer, s.Channels(), s.Cap())
+	return s
 }
 
 // Slice slices buffer with respect to channels.
@@ -183,10 +184,10 @@ func Test{{ .Name }}(t *testing.T) {
 			signal.Allocator{
 				Channels: 3,
 				Capacity: 2,
-			}.{{ .Name }}({{if ne .Interface "Floating"}}signal.{{ .MaxBitDepth }}{{end}}).Append(input).Slice(1, 3),
+			}.{{ .Name }}({{if ne .Interface "Floating"}}signal.{{ .MaxBitDepth }}{{end}}).Append(input.Slice(1, 3)),
 			expected{
 				length:   2,
-				capacity: 4,
+				capacity: 2,
 				data: [][]{{ .Builtin }}{
 					{0, 0},
 					{2, 3},