@matheusbsbs / matheus-bagliano / commits / fa74f32291

reftable/block: reuse compressed array

Similar to the preceding commit, let's reuse the `compressed` array that we use to store compressed data in. This results in a small reduction in memory allocations when writing many refs. Before: HEAP SUMMARY: in use at exit: 671,931 bytes in 151 blocks total heap usage: 22,620,528 allocs, 22,620,377 frees, 1,245,549,984 bytes allocated After: HEAP SUMMARY: in use at exit: 671,931 bytes in 151 blocks total heap usage: 22,618,257 allocs, 22,618,106 frees, 1,236,351,528 bytes allocated So while the reduction in allocations isn't really all that big, it's a low hanging fruit and thus there isn't much of a reason not to pick it. Signed-off-by: Patrick Steinhardt <ps@pks.im> Signed-off-by: Junio C Hamano <gitster@pobox.com>

Patrick Steinhardt committed Apr 8, 2024 at 14:24 UTC fa74f32291d0e2b642345d25e16724567f9b881f

2 files changed +8 -9

reftable/block.c

+5 -9

@@ -150,7 +150,6 @@ int block_writer_finish(struct block_writer *w)

150 if (block_writer_type(w) == BLOCK_TYPE_LOG) {

151 int block_header_skip = 4 + w->header_off;

152 uLongf src_len = w->next - block_header_skip, compressed_len;

153 - unsigned char *compressed;

153 int ret;

154

155 ret = deflateReset(w->zstream);

@@ -163,9 +162,9 @@ int block_writer_finish(struct block_writer *w)

162 * is guaranteed to return `Z_STREAM_END`.

163 */

164 compressed_len = deflateBound(w->zstream, src_len);

166 - REFTABLE_ALLOC_ARRAY(compressed, compressed_len);

165 + REFTABLE_ALLOC_GROW(w->compressed, compressed_len, w->compressed_cap);

166

168 - w->zstream->next_out = compressed;

167 + w->zstream->next_out = w->compressed;

168 w->zstream->avail_out = compressed_len;

169 w->zstream->next_in = w->buf + block_header_skip;

170 w->zstream->avail_in = src_len;

@@ -177,21 +176,17 @@ int block_writer_finish(struct block_writer *w)

176 * guaranteed to succeed according to the zlib documentation.

177 */

178 ret = deflate(w->zstream, Z_FINISH);

180 - if (ret != Z_STREAM_END) {

181 - reftable_free(compressed);

179 + if (ret != Z_STREAM_END)

180 return REFTABLE_ZLIB_ERROR;

183 - }

181

182 /*

183 * Overwrite the uncompressed data we have already written and

184 * adjust the `next` pointer to point right after the

185 * compressed data.

186 */

190 - memcpy(w->buf + block_header_skip, compressed,

187 + memcpy(w->buf + block_header_skip, w->compressed,

188 w->zstream->total_out);

189 w->next = w->zstream->total_out + block_header_skip;

193 -

194 - reftable_free(compressed);

190 }

191

192 return w->next;

@@ -450,6 +445,7 @@ void block_writer_release(struct block_writer *bw)

445 deflateEnd(bw->zstream);

446 FREE_AND_NULL(bw->zstream);

447 FREE_AND_NULL(bw->restarts);

448 + FREE_AND_NULL(bw->compressed);

449 strbuf_release(&bw->last_key);

450 /* the block is not owned. */

451 }

reftable/block.h

@@ -19,6 +19,9 @@ https://developers.google.com/open-source/licenses/bsd

19 */

20 struct block_writer {

21 z_stream *zstream;

22 + unsigned char *compressed;

23 + size_t compressed_cap;

24 +

25 uint8_t *buf;

26 uint32_t block_size;