From 11a37a07749d48b4930f6652c241cdda4514a0f2 Mon Sep 17 00:00:00 2001 From: Rob Figueiredo Date: Fri, 17 Jan 2020 22:14:50 -0500 Subject: [PATCH] (*Stream).WriteMore: remove implicit Flush I believe that WriteMore should not call Flush for these reasons: 1. This is surprising for users because of inconsistency. Why call Flush in WriteMore and not in WriteObjectEnd? 2. It is not necessary; callers are free to call Flush if their use case demands it. 3. It harms performance in the common case by flushing the buffer much more frequently than it needs to be flushed. The stream benchmark shows a 7% benefit to removing the Flush call, and I observed a similar speedup in my real-world use case. benchmark old ns/op new ns/op delta Benchmark_encode_string_with_SetEscapeHTML-8 442 437 -1.13% Benchmark_jsoniter_large_file-8 21222 21062 -0.75% Benchmark_json_large_file-8 40187 40266 +0.20% Benchmark_stream_encode_big_object-8 8611 7956 -7.61% benchmark old allocs new allocs delta Benchmark_encode_string_with_SetEscapeHTML-8 6 6 +0.00% Benchmark_jsoniter_large_file-8 78 78 +0.00% Benchmark_json_large_file-8 13 13 +0.00% Benchmark_stream_encode_big_object-8 0 0 +0.00% benchmark old bytes new bytes delta Benchmark_encode_string_with_SetEscapeHTML-8 760 760 +0.00% Benchmark_jsoniter_large_file-8 4920 4920 +0.00% Benchmark_json_large_file-8 6640 6640 +0.00% Benchmark_stream_encode_big_object-8 0 0 +0.00% Backwards compatibility - I believe there is little to no risk that this breaks callers. WriteMore does not leave the JSON in a valid state, so it must be followed by other Write* methods. To get the finished JSON out, the caller must already be calling Flush. --- stream.go | 1 - stream_test.go | 13 ++++++++++++- 2 files changed, 12 insertions(+), 2 deletions(-) diff --git a/stream.go b/stream.go index de2c13e..23d8a3a 100644 --- a/stream.go +++ b/stream.go @@ -177,7 +177,6 @@ func (stream *Stream) WriteEmptyObject() { func (stream *Stream) WriteMore() { stream.writeByte(',') stream.writeIndention(0) - stream.Flush() } // WriteArrayStart write [ with possible indention diff --git a/stream_test.go b/stream_test.go index 4100f22..a7018e8 100644 --- a/stream_test.go +++ b/stream_test.go @@ -63,8 +63,19 @@ func (w *NopWriter) Write(p []byte) (n int, err error) { } func Test_flush_buffer_should_stop_grow_buffer(t *testing.T) { + // Stream an array of a zillion zeros. writer := new(NopWriter) - NewEncoder(writer).Encode(make([]int, 10000000)) + stream := NewStream(ConfigDefault, writer, 512) + stream.WriteArrayStart() + for i := 0; i < 10000000; i++ { + stream.WriteInt(0) + stream.WriteMore() + stream.Flush() + } + stream.WriteInt(0) + stream.WriteArrayEnd() + + // Confirm that the buffer didn't have to grow. should := require.New(t) // 512 is the internal buffer size set in NewEncoder