It's not possible to Write to a *bufio.Writer without the []byte argument escaping, due
to the fast path passing p through an interface value:
package bufio
...
func (b *Writer) Write(p []byte) (nn int, err error) {
for len(p) > b.Available() && b.err == nil {
var n int
if b.Buffered() == 0 {
// Large write, empty buffer.
// Write directly from p to avoid copy.
n, b.err = b.wr.Write(p) // <------------ escapes
} else {
n = copy(b.buf[b.n:], p)
b.n += n
b.Flush()
}
nn += n
p = p[n:]
}
if b.err != nil {
return nn, b.err
}
n := copy(b.buf[b.n:], p)
b.n += n
nn += n
return nn, nil
}
Possible solutions:
0) do nothing. accept that it's not possible to have a caller do a small write from a
stack-local byte array. I don't like this option.
1) remove the fast path above. that's also sad, since it'd be worse in the common cases.
2) add a new public method on *bufio.Writer that's like Write, but without its p []byte
argument escaping. This is gross, because it's new API for a performance thing.
3) instead of passing p to b.wr.Write in the line of code labeled above, instead play a
game where we pass a copy of p if &p[0] is on the stack, otherwise pass p directly
(but this would probably involve gross unsafe tricks to avoid the compiler thinking that
p escapes)
4) caller can do a loop on its stack-local byte array and call WriteByte for each input.
this is what I've done so far.
