From c69670c85bf1af1576b1eb93c6eb1adf79c9392a Mon Sep 17 00:00:00 2001 From: Evgeniy Stratonikov Date: Fri, 6 Aug 2021 10:45:27 +0300 Subject: [PATCH] io: use a single slice for numbers MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Slice takes 24 bytes of memory, while we really need only 9. ``` name old time/op new time/op delta Transaction_Bytes-8 667ns ±17% 583ns ± 6% -12.50% (p=0.000 n=10+10) GetVarSize-8 283ns ±11% 189ns ± 5% -33.37% (p=0.000 n=10+10) name old alloc/op new alloc/op delta Transaction_Bytes-8 1.01kB ± 0% 0.88kB ± 0% -12.70% (p=0.000 n=10+10) GetVarSize-8 184B ± 0% 56B ± 0% -69.57% (p=0.000 n=10+10) name old allocs/op new allocs/op delta Transaction_Bytes-8 7.00 ± 0% 6.00 ± 0% -14.29% (p=0.000 n=10+10) GetVarSize-8 3.00 ± 0% 2.00 ± 0% -33.33% (p=0.000 n=10+10) ``` Signed-off-by: Evgeniy Stratonikov --- pkg/io/binaryWriter.go | 35 +++++++++++++---------------------- 1 file changed, 13 insertions(+), 22 deletions(-) diff --git a/pkg/io/binaryWriter.go b/pkg/io/binaryWriter.go index 5ec3e42fa..46915725e 100644 --- a/pkg/io/binaryWriter.go +++ b/pkg/io/binaryWriter.go @@ -11,56 +11,47 @@ import ( // from a struct with many fields. type BinWriter struct { w io.Writer - uv []byte - u64 []byte - u32 []byte - u16 []byte - u8 []byte Err error + uv [9]byte } // NewBinWriterFromIO makes a BinWriter from io.Writer. func NewBinWriterFromIO(iow io.Writer) *BinWriter { - uv := make([]byte, 9) - u64 := uv[:8] - u32 := u64[:4] - u16 := u64[:2] - u8 := u64[:1] - return &BinWriter{w: iow, uv: uv, u64: u64, u32: u32, u16: u16, u8: u8} + return &BinWriter{w: iow} } // WriteU64LE writes an uint64 value into the underlying io.Writer in // little-endian format. func (w *BinWriter) WriteU64LE(u64 uint64) { - binary.LittleEndian.PutUint64(w.u64, u64) - w.WriteBytes(w.u64) + binary.LittleEndian.PutUint64(w.uv[:8], u64) + w.WriteBytes(w.uv[:8]) } // WriteU32LE writes an uint32 value into the underlying io.Writer in // little-endian format. func (w *BinWriter) WriteU32LE(u32 uint32) { - binary.LittleEndian.PutUint32(w.u32, u32) - w.WriteBytes(w.u32) + binary.LittleEndian.PutUint32(w.uv[:4], u32) + w.WriteBytes(w.uv[:4]) } // WriteU16LE writes an uint16 value into the underlying io.Writer in // little-endian format. func (w *BinWriter) WriteU16LE(u16 uint16) { - binary.LittleEndian.PutUint16(w.u16, u16) - w.WriteBytes(w.u16) + binary.LittleEndian.PutUint16(w.uv[:2], u16) + w.WriteBytes(w.uv[:2]) } // WriteU16BE writes an uint16 value into the underlying io.Writer in // big-endian format. func (w *BinWriter) WriteU16BE(u16 uint16) { - binary.BigEndian.PutUint16(w.u16, u16) - w.WriteBytes(w.u16) + binary.BigEndian.PutUint16(w.uv[:2], u16) + w.WriteBytes(w.uv[:2]) } // WriteB writes a byte into the underlying io.Writer. func (w *BinWriter) WriteB(u8 byte) { - w.u8[0] = u8 - w.WriteBytes(w.u8) + w.uv[0] = u8 + w.WriteBytes(w.uv[:1]) } // WriteBool writes a boolean value into the underlying io.Writer encoded as @@ -108,7 +99,7 @@ func (w *BinWriter) WriteVarUint(val uint64) { return } - n := PutVarUint(w.uv, val) + n := PutVarUint(w.uv[:], val) w.WriteBytes(w.uv[:n]) }