mirror of
https://github.com/git/git.git
synced 2024-05-07 17:26:09 +02:00
Merge branch 'ps/reftable-block-iteration-optim'
The code to iterate over reftable blocks has seen some optimization to reduce memory allocation and deallocation. * ps/reftable-block-iteration-optim: reftable/block: avoid copying block iterators on seek reftable/block: reuse `zstream` state on inflation reftable/block: open-code call to `uncompress2()` reftable/block: reuse uncompressed blocks reftable/reader: iterate to next block in place reftable/block: move ownership of block reader into `struct table_iter` reftable/block: introduce `block_reader_release()` reftable/block: better grouping of functions reftable/block: merge `block_iter_seek()` and `block_reader_seek()` reftable/block: rename `block_reader_start()`
This commit is contained in:
commit
33bbc21c92
176
reftable/block.c
176
reftable/block.c
|
@ -175,11 +175,6 @@ int block_writer_finish(struct block_writer *w)
|
|||
return w->next;
|
||||
}
|
||||
|
||||
uint8_t block_reader_type(struct block_reader *r)
|
||||
{
|
||||
return r->block.data[r->header_off];
|
||||
}
|
||||
|
||||
int block_reader_init(struct block_reader *br, struct reftable_block *block,
|
||||
uint32_t header_off, uint32_t table_block_size,
|
||||
int hash_size)
|
||||
|
@ -191,7 +186,8 @@ int block_reader_init(struct block_reader *br, struct reftable_block *block,
|
|||
uint16_t restart_count = 0;
|
||||
uint32_t restart_start = 0;
|
||||
uint8_t *restart_bytes = NULL;
|
||||
uint8_t *uncompressed = NULL;
|
||||
|
||||
reftable_block_done(&br->block);
|
||||
|
||||
if (!reftable_is_block_type(typ)) {
|
||||
err = REFTABLE_FORMAT_ERROR;
|
||||
|
@ -199,37 +195,57 @@ int block_reader_init(struct block_reader *br, struct reftable_block *block,
|
|||
}
|
||||
|
||||
if (typ == BLOCK_TYPE_LOG) {
|
||||
int block_header_skip = 4 + header_off;
|
||||
uLongf dst_len = sz - block_header_skip; /* total size of dest
|
||||
buffer. */
|
||||
uLongf src_len = block->len - block_header_skip;
|
||||
uint32_t block_header_skip = 4 + header_off;
|
||||
uLong dst_len = sz - block_header_skip;
|
||||
uLong src_len = block->len - block_header_skip;
|
||||
|
||||
/* Log blocks specify the *uncompressed* size in their header. */
|
||||
REFTABLE_ALLOC_ARRAY(uncompressed, sz);
|
||||
REFTABLE_ALLOC_GROW(br->uncompressed_data, sz,
|
||||
br->uncompressed_cap);
|
||||
|
||||
/* Copy over the block header verbatim. It's not compressed. */
|
||||
memcpy(uncompressed, block->data, block_header_skip);
|
||||
memcpy(br->uncompressed_data, block->data, block_header_skip);
|
||||
|
||||
/* Uncompress */
|
||||
if (Z_OK !=
|
||||
uncompress2(uncompressed + block_header_skip, &dst_len,
|
||||
block->data + block_header_skip, &src_len)) {
|
||||
if (!br->zstream) {
|
||||
REFTABLE_CALLOC_ARRAY(br->zstream, 1);
|
||||
err = inflateInit(br->zstream);
|
||||
} else {
|
||||
err = inflateReset(br->zstream);
|
||||
}
|
||||
if (err != Z_OK) {
|
||||
err = REFTABLE_ZLIB_ERROR;
|
||||
goto done;
|
||||
}
|
||||
|
||||
if (dst_len + block_header_skip != sz) {
|
||||
br->zstream->next_in = block->data + block_header_skip;
|
||||
br->zstream->avail_in = src_len;
|
||||
br->zstream->next_out = br->uncompressed_data + block_header_skip;
|
||||
br->zstream->avail_out = dst_len;
|
||||
|
||||
/*
|
||||
* We know both input as well as output size, and we know that
|
||||
* the sizes should never be bigger than `uInt_MAX` because
|
||||
* blocks can at most be 16MB large. We can thus use `Z_FINISH`
|
||||
* here to instruct zlib to inflate the data in one go, which
|
||||
* is more efficient than using `Z_NO_FLUSH`.
|
||||
*/
|
||||
err = inflate(br->zstream, Z_FINISH);
|
||||
if (err != Z_STREAM_END) {
|
||||
err = REFTABLE_ZLIB_ERROR;
|
||||
goto done;
|
||||
}
|
||||
err = 0;
|
||||
|
||||
if (br->zstream->total_out + block_header_skip != sz) {
|
||||
err = REFTABLE_FORMAT_ERROR;
|
||||
goto done;
|
||||
}
|
||||
|
||||
/* We're done with the input data. */
|
||||
reftable_block_done(block);
|
||||
block->data = uncompressed;
|
||||
uncompressed = NULL;
|
||||
block->data = br->uncompressed_data;
|
||||
block->len = sz;
|
||||
block->source = malloc_block_source();
|
||||
full_block_size = src_len + block_header_skip;
|
||||
full_block_size = src_len + block_header_skip - br->zstream->avail_in;
|
||||
} else if (full_block_size == 0) {
|
||||
full_block_size = sz;
|
||||
} else if (sz < full_block_size && sz < block->len &&
|
||||
|
@ -257,18 +273,52 @@ int block_reader_init(struct block_reader *br, struct reftable_block *block,
|
|||
br->restart_bytes = restart_bytes;
|
||||
|
||||
done:
|
||||
reftable_free(uncompressed);
|
||||
return err;
|
||||
}
|
||||
|
||||
static uint32_t block_reader_restart_offset(struct block_reader *br, int i)
|
||||
void block_reader_release(struct block_reader *br)
|
||||
{
|
||||
inflateEnd(br->zstream);
|
||||
reftable_free(br->zstream);
|
||||
reftable_free(br->uncompressed_data);
|
||||
reftable_block_done(&br->block);
|
||||
}
|
||||
|
||||
uint8_t block_reader_type(const struct block_reader *r)
|
||||
{
|
||||
return r->block.data[r->header_off];
|
||||
}
|
||||
|
||||
int block_reader_first_key(const struct block_reader *br, struct strbuf *key)
|
||||
{
|
||||
int off = br->header_off + 4, n;
|
||||
struct string_view in = {
|
||||
.buf = br->block.data + off,
|
||||
.len = br->block_len - off,
|
||||
};
|
||||
uint8_t extra = 0;
|
||||
|
||||
strbuf_reset(key);
|
||||
|
||||
n = reftable_decode_key(key, &extra, in);
|
||||
if (n < 0)
|
||||
return n;
|
||||
if (!key->len)
|
||||
return REFTABLE_FORMAT_ERROR;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static uint32_t block_reader_restart_offset(const struct block_reader *br, int i)
|
||||
{
|
||||
return get_be24(br->restart_bytes + 3 * i);
|
||||
}
|
||||
|
||||
void block_reader_start(struct block_reader *br, struct block_iter *it)
|
||||
void block_iter_seek_start(struct block_iter *it, const struct block_reader *br)
|
||||
{
|
||||
it->br = br;
|
||||
it->block = br->block.data;
|
||||
it->block_len = br->block_len;
|
||||
it->hash_size = br->hash_size;
|
||||
strbuf_reset(&it->last_key);
|
||||
it->next_off = br->header_off + 4;
|
||||
}
|
||||
|
@ -276,7 +326,7 @@ void block_reader_start(struct block_reader *br, struct block_iter *it)
|
|||
struct restart_needle_less_args {
|
||||
int error;
|
||||
struct strbuf needle;
|
||||
struct block_reader *reader;
|
||||
const struct block_reader *reader;
|
||||
};
|
||||
|
||||
static int restart_needle_less(size_t idx, void *_args)
|
||||
|
@ -315,25 +365,17 @@ static int restart_needle_less(size_t idx, void *_args)
|
|||
return args->needle.len < suffix_len;
|
||||
}
|
||||
|
||||
void block_iter_copy_from(struct block_iter *dest, struct block_iter *src)
|
||||
{
|
||||
dest->br = src->br;
|
||||
dest->next_off = src->next_off;
|
||||
strbuf_reset(&dest->last_key);
|
||||
strbuf_addbuf(&dest->last_key, &src->last_key);
|
||||
}
|
||||
|
||||
int block_iter_next(struct block_iter *it, struct reftable_record *rec)
|
||||
{
|
||||
struct string_view in = {
|
||||
.buf = it->br->block.data + it->next_off,
|
||||
.len = it->br->block_len - it->next_off,
|
||||
.buf = (unsigned char *) it->block + it->next_off,
|
||||
.len = it->block_len - it->next_off,
|
||||
};
|
||||
struct string_view start = in;
|
||||
uint8_t extra = 0;
|
||||
int n = 0;
|
||||
|
||||
if (it->next_off >= it->br->block_len)
|
||||
if (it->next_off >= it->block_len)
|
||||
return 1;
|
||||
|
||||
n = reftable_decode_key(&it->last_key, &extra, in);
|
||||
|
@ -343,7 +385,7 @@ int block_iter_next(struct block_iter *it, struct reftable_record *rec)
|
|||
return REFTABLE_FORMAT_ERROR;
|
||||
|
||||
string_view_consume(&in, n);
|
||||
n = reftable_record_decode(rec, it->last_key, extra, in, it->br->hash_size,
|
||||
n = reftable_record_decode(rec, it->last_key, extra, in, it->hash_size,
|
||||
&it->scratch);
|
||||
if (n < 0)
|
||||
return -1;
|
||||
|
@ -353,29 +395,13 @@ int block_iter_next(struct block_iter *it, struct reftable_record *rec)
|
|||
return 0;
|
||||
}
|
||||
|
||||
int block_reader_first_key(struct block_reader *br, struct strbuf *key)
|
||||
void block_iter_reset(struct block_iter *it)
|
||||
{
|
||||
int off = br->header_off + 4, n;
|
||||
struct string_view in = {
|
||||
.buf = br->block.data + off,
|
||||
.len = br->block_len - off,
|
||||
};
|
||||
uint8_t extra = 0;
|
||||
|
||||
strbuf_reset(key);
|
||||
|
||||
n = reftable_decode_key(key, &extra, in);
|
||||
if (n < 0)
|
||||
return n;
|
||||
if (!key->len)
|
||||
return REFTABLE_FORMAT_ERROR;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int block_iter_seek(struct block_iter *it, struct strbuf *want)
|
||||
{
|
||||
return block_reader_seek(it->br, it, want);
|
||||
strbuf_reset(&it->last_key);
|
||||
it->next_off = 0;
|
||||
it->block = NULL;
|
||||
it->block_len = 0;
|
||||
it->hash_size = 0;
|
||||
}
|
||||
|
||||
void block_iter_close(struct block_iter *it)
|
||||
|
@ -384,14 +410,13 @@ void block_iter_close(struct block_iter *it)
|
|||
strbuf_release(&it->scratch);
|
||||
}
|
||||
|
||||
int block_reader_seek(struct block_reader *br, struct block_iter *it,
|
||||
struct strbuf *want)
|
||||
int block_iter_seek_key(struct block_iter *it, const struct block_reader *br,
|
||||
struct strbuf *want)
|
||||
{
|
||||
struct restart_needle_less_args args = {
|
||||
.needle = *want,
|
||||
.reader = br,
|
||||
};
|
||||
struct block_iter next = BLOCK_ITER_INIT;
|
||||
struct reftable_record rec;
|
||||
int err = 0;
|
||||
size_t i;
|
||||
|
@ -436,7 +461,9 @@ int block_reader_seek(struct block_reader *br, struct block_iter *it,
|
|||
it->next_off = block_reader_restart_offset(br, i - 1);
|
||||
else
|
||||
it->next_off = br->header_off + 4;
|
||||
it->br = br;
|
||||
it->block = br->block.data;
|
||||
it->block_len = br->block_len;
|
||||
it->hash_size = br->hash_size;
|
||||
|
||||
reftable_record_init(&rec, block_reader_type(br));
|
||||
|
||||
|
@ -448,11 +475,13 @@ int block_reader_seek(struct block_reader *br, struct block_iter *it,
|
|||
* far and then back up.
|
||||
*/
|
||||
while (1) {
|
||||
block_iter_copy_from(&next, it);
|
||||
err = block_iter_next(&next, &rec);
|
||||
size_t prev_off = it->next_off;
|
||||
|
||||
err = block_iter_next(it, &rec);
|
||||
if (err < 0)
|
||||
goto done;
|
||||
if (err > 0) {
|
||||
it->next_off = prev_off;
|
||||
err = 0;
|
||||
goto done;
|
||||
}
|
||||
|
@ -463,18 +492,23 @@ int block_reader_seek(struct block_reader *br, struct block_iter *it,
|
|||
* record does not exist in the block and can thus abort early.
|
||||
* In case it is equal to the sought-after key we have found
|
||||
* the desired record.
|
||||
*
|
||||
* Note that we store the next record's key record directly in
|
||||
* `last_key` without restoring the key of the preceding record
|
||||
* in case we need to go one record back. This is safe to do as
|
||||
* `block_iter_next()` would return the ref whose key is equal
|
||||
* to `last_key` now, and naturally all keys share a prefix
|
||||
* with themselves.
|
||||
*/
|
||||
reftable_record_key(&rec, &it->last_key);
|
||||
if (strbuf_cmp(&it->last_key, want) >= 0)
|
||||
if (strbuf_cmp(&it->last_key, want) >= 0) {
|
||||
it->next_off = prev_off;
|
||||
goto done;
|
||||
|
||||
block_iter_copy_from(it, &next);
|
||||
}
|
||||
}
|
||||
|
||||
done:
|
||||
block_iter_close(&next);
|
||||
reftable_record_release(&rec);
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
|
|
|
@ -56,6 +56,8 @@ int block_writer_finish(struct block_writer *w);
|
|||
/* clears out internally allocated block_writer members. */
|
||||
void block_writer_release(struct block_writer *bw);
|
||||
|
||||
struct z_stream;
|
||||
|
||||
/* Read a block. */
|
||||
struct block_reader {
|
||||
/* offset of the block header; nonzero for the first block in a
|
||||
|
@ -66,6 +68,11 @@ struct block_reader {
|
|||
struct reftable_block block;
|
||||
int hash_size;
|
||||
|
||||
/* Uncompressed data for log entries. */
|
||||
z_stream *zstream;
|
||||
unsigned char *uncompressed_data;
|
||||
size_t uncompressed_cap;
|
||||
|
||||
/* size of the data, excluding restart data. */
|
||||
uint32_t block_len;
|
||||
uint8_t *restart_bytes;
|
||||
|
@ -76,11 +83,26 @@ struct block_reader {
|
|||
uint32_t full_block_size;
|
||||
};
|
||||
|
||||
/* initializes a block reader. */
|
||||
int block_reader_init(struct block_reader *br, struct reftable_block *bl,
|
||||
uint32_t header_off, uint32_t table_block_size,
|
||||
int hash_size);
|
||||
|
||||
void block_reader_release(struct block_reader *br);
|
||||
|
||||
/* Returns the block type (eg. 'r' for refs) */
|
||||
uint8_t block_reader_type(const struct block_reader *r);
|
||||
|
||||
/* Decodes the first key in the block */
|
||||
int block_reader_first_key(const struct block_reader *br, struct strbuf *key);
|
||||
|
||||
/* Iterate over entries in a block */
|
||||
struct block_iter {
|
||||
/* offset within the block of the next entry to read. */
|
||||
uint32_t next_off;
|
||||
struct block_reader *br;
|
||||
const unsigned char *block;
|
||||
size_t block_len;
|
||||
int hash_size;
|
||||
|
||||
/* key for last entry we read. */
|
||||
struct strbuf last_key;
|
||||
|
@ -92,31 +114,18 @@ struct block_iter {
|
|||
.scratch = STRBUF_INIT, \
|
||||
}
|
||||
|
||||
/* initializes a block reader. */
|
||||
int block_reader_init(struct block_reader *br, struct reftable_block *bl,
|
||||
uint32_t header_off, uint32_t table_block_size,
|
||||
int hash_size);
|
||||
|
||||
/* Position `it` at start of the block */
|
||||
void block_reader_start(struct block_reader *br, struct block_iter *it);
|
||||
void block_iter_seek_start(struct block_iter *it, const struct block_reader *br);
|
||||
|
||||
/* Position `it` to the `want` key in the block */
|
||||
int block_reader_seek(struct block_reader *br, struct block_iter *it,
|
||||
struct strbuf *want);
|
||||
|
||||
/* Returns the block type (eg. 'r' for refs) */
|
||||
uint8_t block_reader_type(struct block_reader *r);
|
||||
|
||||
/* Decodes the first key in the block */
|
||||
int block_reader_first_key(struct block_reader *br, struct strbuf *key);
|
||||
|
||||
void block_iter_copy_from(struct block_iter *dest, struct block_iter *src);
|
||||
int block_iter_seek_key(struct block_iter *it, const struct block_reader *br,
|
||||
struct strbuf *want);
|
||||
|
||||
/* return < 0 for error, 0 for OK, > 0 for EOF. */
|
||||
int block_iter_next(struct block_iter *it, struct reftable_record *rec);
|
||||
|
||||
/* Seek to `want` with in the block pointed to by `it` */
|
||||
int block_iter_seek(struct block_iter *it, struct strbuf *want);
|
||||
/* Reset the block iterator to pristine state without releasing its memory. */
|
||||
void block_iter_reset(struct block_iter *it);
|
||||
|
||||
/* deallocate memory for `it`. The block reader and its block is left intact. */
|
||||
void block_iter_close(struct block_iter *it);
|
||||
|
|
|
@ -69,7 +69,7 @@ static void test_block_read_write(void)
|
|||
|
||||
block_reader_init(&br, &block, header_off, block_size, GIT_SHA1_RAWSZ);
|
||||
|
||||
block_reader_start(&br, &it);
|
||||
block_iter_seek_start(&it, &br);
|
||||
|
||||
while (1) {
|
||||
int r = block_iter_next(&it, &rec);
|
||||
|
@ -89,7 +89,7 @@ static void test_block_read_write(void)
|
|||
strbuf_reset(&want);
|
||||
strbuf_addstr(&want, names[i]);
|
||||
|
||||
n = block_reader_seek(&br, &it, &want);
|
||||
n = block_iter_seek_key(&it, &br, &want);
|
||||
EXPECT(n == 0);
|
||||
|
||||
n = block_iter_next(&it, &rec);
|
||||
|
@ -98,7 +98,7 @@ static void test_block_read_write(void)
|
|||
EXPECT_STREQ(names[i], rec.u.ref.refname);
|
||||
|
||||
want.len--;
|
||||
n = block_reader_seek(&br, &it, &want);
|
||||
n = block_iter_seek_key(&it, &br, &want);
|
||||
EXPECT(n == 0);
|
||||
|
||||
n = block_iter_next(&it, &rec);
|
||||
|
|
|
@ -115,7 +115,7 @@ static int indexed_table_ref_iter_next_block(struct indexed_table_ref_iter *it)
|
|||
/* indexed block does not exist. */
|
||||
return REFTABLE_FORMAT_ERROR;
|
||||
}
|
||||
block_reader_start(&it->block_reader, &it->cur);
|
||||
block_iter_seek_start(&it->cur, &it->block_reader);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
|
@ -220,6 +220,7 @@ struct table_iter {
|
|||
struct reftable_reader *r;
|
||||
uint8_t typ;
|
||||
uint64_t block_off;
|
||||
struct block_reader br;
|
||||
struct block_iter bi;
|
||||
int is_finished;
|
||||
};
|
||||
|
@ -227,16 +228,6 @@ struct table_iter {
|
|||
.bi = BLOCK_ITER_INIT \
|
||||
}
|
||||
|
||||
static void table_iter_copy_from(struct table_iter *dest,
|
||||
struct table_iter *src)
|
||||
{
|
||||
dest->r = src->r;
|
||||
dest->typ = src->typ;
|
||||
dest->block_off = src->block_off;
|
||||
dest->is_finished = src->is_finished;
|
||||
block_iter_copy_from(&dest->bi, &src->bi);
|
||||
}
|
||||
|
||||
static int table_iter_next_in_block(struct table_iter *ti,
|
||||
struct reftable_record *rec)
|
||||
{
|
||||
|
@ -250,14 +241,8 @@ static int table_iter_next_in_block(struct table_iter *ti,
|
|||
|
||||
static void table_iter_block_done(struct table_iter *ti)
|
||||
{
|
||||
if (!ti->bi.br) {
|
||||
return;
|
||||
}
|
||||
reftable_block_done(&ti->bi.br->block);
|
||||
FREE_AND_NULL(ti->bi.br);
|
||||
|
||||
ti->bi.last_key.len = 0;
|
||||
ti->bi.next_off = 0;
|
||||
block_reader_release(&ti->br);
|
||||
block_iter_reset(&ti->bi);
|
||||
}
|
||||
|
||||
static int32_t extract_block_size(uint8_t *data, uint8_t *typ, uint64_t off,
|
||||
|
@ -321,32 +306,27 @@ int reader_init_block_reader(struct reftable_reader *r, struct block_reader *br,
|
|||
return err;
|
||||
}
|
||||
|
||||
static int table_iter_next_block(struct table_iter *dest,
|
||||
struct table_iter *src)
|
||||
static void table_iter_close(struct table_iter *ti)
|
||||
{
|
||||
uint64_t next_block_off = src->block_off + src->bi.br->full_block_size;
|
||||
struct block_reader br = { 0 };
|
||||
int err = 0;
|
||||
table_iter_block_done(ti);
|
||||
block_iter_close(&ti->bi);
|
||||
}
|
||||
|
||||
dest->r = src->r;
|
||||
dest->typ = src->typ;
|
||||
dest->block_off = next_block_off;
|
||||
static int table_iter_next_block(struct table_iter *ti)
|
||||
{
|
||||
uint64_t next_block_off = ti->block_off + ti->br.full_block_size;
|
||||
int err;
|
||||
|
||||
err = reader_init_block_reader(src->r, &br, next_block_off, src->typ);
|
||||
if (err > 0) {
|
||||
dest->is_finished = 1;
|
||||
return 1;
|
||||
}
|
||||
if (err != 0)
|
||||
err = reader_init_block_reader(ti->r, &ti->br, next_block_off, ti->typ);
|
||||
if (err > 0)
|
||||
ti->is_finished = 1;
|
||||
if (err)
|
||||
return err;
|
||||
else {
|
||||
struct block_reader *brp =
|
||||
reftable_malloc(sizeof(struct block_reader));
|
||||
*brp = br;
|
||||
|
||||
dest->is_finished = 0;
|
||||
block_reader_start(brp, &dest->bi);
|
||||
}
|
||||
ti->block_off = next_block_off;
|
||||
ti->is_finished = 0;
|
||||
block_iter_seek_start(&ti->bi, &ti->br);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
@ -356,7 +336,6 @@ static int table_iter_next(struct table_iter *ti, struct reftable_record *rec)
|
|||
return REFTABLE_API_ERROR;
|
||||
|
||||
while (1) {
|
||||
struct table_iter next = TABLE_ITER_INIT;
|
||||
int err;
|
||||
|
||||
if (ti->is_finished)
|
||||
|
@ -376,15 +355,11 @@ static int table_iter_next(struct table_iter *ti, struct reftable_record *rec)
|
|||
* table and retry. If there are no more blocks then the
|
||||
* iterator is drained.
|
||||
*/
|
||||
err = table_iter_next_block(&next, ti);
|
||||
table_iter_block_done(ti);
|
||||
err = table_iter_next_block(ti);
|
||||
if (err) {
|
||||
ti->is_finished = 1;
|
||||
return err;
|
||||
}
|
||||
|
||||
table_iter_copy_from(ti, &next);
|
||||
block_iter_close(&next.bi);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -393,16 +368,14 @@ static int table_iter_next_void(void *ti, struct reftable_record *rec)
|
|||
return table_iter_next(ti, rec);
|
||||
}
|
||||
|
||||
static void table_iter_close(void *p)
|
||||
static void table_iter_close_void(void *ti)
|
||||
{
|
||||
struct table_iter *ti = p;
|
||||
table_iter_block_done(ti);
|
||||
block_iter_close(&ti->bi);
|
||||
table_iter_close(ti);
|
||||
}
|
||||
|
||||
static struct reftable_iterator_vtable table_iter_vtable = {
|
||||
.next = &table_iter_next_void,
|
||||
.close = &table_iter_close,
|
||||
.close = &table_iter_close_void,
|
||||
};
|
||||
|
||||
static void iterator_from_table_iter(struct reftable_iterator *it,
|
||||
|
@ -417,19 +390,16 @@ static int reader_table_iter_at(struct reftable_reader *r,
|
|||
struct table_iter *ti, uint64_t off,
|
||||
uint8_t typ)
|
||||
{
|
||||
struct block_reader br = { 0 };
|
||||
struct block_reader *brp = NULL;
|
||||
int err;
|
||||
|
||||
int err = reader_init_block_reader(r, &br, off, typ);
|
||||
err = reader_init_block_reader(r, &ti->br, off, typ);
|
||||
if (err != 0)
|
||||
return err;
|
||||
|
||||
brp = reftable_malloc(sizeof(struct block_reader));
|
||||
*brp = br;
|
||||
ti->r = r;
|
||||
ti->typ = block_reader_type(brp);
|
||||
ti->typ = block_reader_type(&ti->br);
|
||||
ti->block_off = off;
|
||||
block_reader_start(brp, &ti->bi);
|
||||
block_iter_seek_start(&ti->bi, &ti->br);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
@ -454,23 +424,52 @@ static int reader_seek_linear(struct table_iter *ti,
|
|||
{
|
||||
struct strbuf want_key = STRBUF_INIT;
|
||||
struct strbuf got_key = STRBUF_INIT;
|
||||
struct table_iter next = TABLE_ITER_INIT;
|
||||
struct reftable_record rec;
|
||||
int err = -1;
|
||||
|
||||
reftable_record_init(&rec, reftable_record_type(want));
|
||||
reftable_record_key(want, &want_key);
|
||||
|
||||
/*
|
||||
* First we need to locate the block that must contain our record. To
|
||||
* do so we scan through blocks linearly until we find the first block
|
||||
* whose first key is bigger than our wanted key. Once we have found
|
||||
* that block we know that the key must be contained in the preceding
|
||||
* block.
|
||||
*
|
||||
* This algorithm is somewhat unfortunate because it means that we
|
||||
* always have to seek one block too far and then back up. But as we
|
||||
* can only decode the _first_ key of a block but not its _last_ key we
|
||||
* have no other way to do this.
|
||||
*/
|
||||
while (1) {
|
||||
err = table_iter_next_block(&next, ti);
|
||||
struct table_iter next = *ti;
|
||||
|
||||
/*
|
||||
* We must be careful to not modify underlying data of `ti`
|
||||
* because we may find that `next` does not contain our desired
|
||||
* block, but that `ti` does. In that case, we would discard
|
||||
* `next` and continue with `ti`.
|
||||
*
|
||||
* This also means that we cannot reuse allocated memory for
|
||||
* `next` here. While it would be great if we could, it should
|
||||
* in practice not be too bad given that we should only ever
|
||||
* end up doing linear seeks with at most three blocks. As soon
|
||||
* as we have more than three blocks we would have an index, so
|
||||
* we would not do a linear search there anymore.
|
||||
*/
|
||||
memset(&next.br.block, 0, sizeof(next.br.block));
|
||||
next.br.zstream = NULL;
|
||||
next.br.uncompressed_data = NULL;
|
||||
next.br.uncompressed_cap = 0;
|
||||
|
||||
err = table_iter_next_block(&next);
|
||||
if (err < 0)
|
||||
goto done;
|
||||
|
||||
if (err > 0) {
|
||||
if (err > 0)
|
||||
break;
|
||||
}
|
||||
|
||||
err = block_reader_first_key(next.bi.br, &got_key);
|
||||
err = block_reader_first_key(&next.br, &got_key);
|
||||
if (err < 0)
|
||||
goto done;
|
||||
|
||||
|
@ -480,16 +479,20 @@ static int reader_seek_linear(struct table_iter *ti,
|
|||
}
|
||||
|
||||
table_iter_block_done(ti);
|
||||
table_iter_copy_from(ti, &next);
|
||||
*ti = next;
|
||||
}
|
||||
|
||||
err = block_iter_seek(&ti->bi, &want_key);
|
||||
/*
|
||||
* We have located the block that must contain our record, so we seek
|
||||
* the wanted key inside of it. If the block does not contain our key
|
||||
* we know that the corresponding record does not exist.
|
||||
*/
|
||||
err = block_iter_seek_key(&ti->bi, &ti->br, &want_key);
|
||||
if (err < 0)
|
||||
goto done;
|
||||
err = 0;
|
||||
|
||||
done:
|
||||
block_iter_close(&next.bi);
|
||||
reftable_record_release(&rec);
|
||||
strbuf_release(&want_key);
|
||||
strbuf_release(&got_key);
|
||||
|
@ -508,6 +511,7 @@ static int reader_seek_indexed(struct reftable_reader *r,
|
|||
.u.idx = { .last_key = STRBUF_INIT },
|
||||
};
|
||||
struct table_iter index_iter = TABLE_ITER_INIT;
|
||||
struct table_iter empty = TABLE_ITER_INIT;
|
||||
struct table_iter next = TABLE_ITER_INIT;
|
||||
int err = 0;
|
||||
|
||||
|
@ -549,7 +553,6 @@ static int reader_seek_indexed(struct reftable_reader *r,
|
|||
* not exist.
|
||||
*/
|
||||
err = table_iter_next(&index_iter, &index_result);
|
||||
table_iter_block_done(&index_iter);
|
||||
if (err != 0)
|
||||
goto done;
|
||||
|
||||
|
@ -558,7 +561,7 @@ static int reader_seek_indexed(struct reftable_reader *r,
|
|||
if (err != 0)
|
||||
goto done;
|
||||
|
||||
err = block_iter_seek(&next.bi, &want_index.u.idx.last_key);
|
||||
err = block_iter_seek_key(&next.bi, &next.br, &want_index.u.idx.last_key);
|
||||
if (err < 0)
|
||||
goto done;
|
||||
|
||||
|
@ -572,18 +575,20 @@ static int reader_seek_indexed(struct reftable_reader *r,
|
|||
break;
|
||||
}
|
||||
|
||||
table_iter_copy_from(&index_iter, &next);
|
||||
table_iter_close(&index_iter);
|
||||
index_iter = next;
|
||||
next = empty;
|
||||
}
|
||||
|
||||
if (err == 0) {
|
||||
struct table_iter empty = TABLE_ITER_INIT;
|
||||
struct table_iter *malloced = reftable_calloc(1, sizeof(*malloced));
|
||||
*malloced = empty;
|
||||
table_iter_copy_from(malloced, &next);
|
||||
*malloced = next;
|
||||
next = empty;
|
||||
iterator_from_table_iter(it, malloced);
|
||||
}
|
||||
|
||||
done:
|
||||
block_iter_close(&next.bi);
|
||||
table_iter_close(&next);
|
||||
table_iter_close(&index_iter);
|
||||
reftable_record_release(&want_index);
|
||||
reftable_record_release(&index_result);
|
||||
|
@ -597,25 +602,28 @@ static int reader_seek_internal(struct reftable_reader *r,
|
|||
struct reftable_reader_offsets *offs =
|
||||
reader_offsets_for(r, reftable_record_type(rec));
|
||||
uint64_t idx = offs->index_offset;
|
||||
struct table_iter ti = TABLE_ITER_INIT;
|
||||
int err = 0;
|
||||
struct table_iter ti = TABLE_ITER_INIT, *p;
|
||||
int err;
|
||||
|
||||
if (idx > 0)
|
||||
return reader_seek_indexed(r, it, rec);
|
||||
|
||||
err = reader_start(r, &ti, reftable_record_type(rec), 0);
|
||||
if (err < 0)
|
||||
return err;
|
||||
goto out;
|
||||
|
||||
err = reader_seek_linear(&ti, rec);
|
||||
if (err < 0)
|
||||
return err;
|
||||
else {
|
||||
struct table_iter *p =
|
||||
reftable_malloc(sizeof(struct table_iter));
|
||||
*p = ti;
|
||||
iterator_from_table_iter(it, p);
|
||||
}
|
||||
goto out;
|
||||
|
||||
return 0;
|
||||
REFTABLE_ALLOC_ARRAY(p, 1);
|
||||
*p = ti;
|
||||
iterator_from_table_iter(it, p);
|
||||
|
||||
out:
|
||||
if (err)
|
||||
table_iter_close(&ti);
|
||||
return err;
|
||||
}
|
||||
|
||||
static int reader_seek(struct reftable_reader *r, struct reftable_iterator *it,
|
||||
|
|
Loading…
Reference in New Issue