mirror of
https://github.com/git/git
synced 2024-06-30 22:54:27 +00:00
bb2d6be4c1
For each subiterator, the merged table needs to track their current
record. This record is owned by the priority queue though instead of by
the merged iterator. This is not optimal performance-wise.
For one, we need to move around records whenever we add or remove a
record from the priority queue. Thus, the bigger the entries the more
bytes we need to copy around. And compared to pointers, a reftable
record is rather on the bigger side. The other issue is that this makes
it harder to reuse the records.
Refactor the code so that the merged iterator tracks ownership of the
records per-subiter. Instead of having records in the priority queue, we
can now use mere pointers to the per-subiter records. This also allows
us to swap records between the caller and the per-subiter record instead
of doing an actual copy via `reftable_record_copy_from()`, which removes
the need to release the caller-provided record.
This results in a noticeable speedup when iterating through many refs.
The following benchmark iterates through 1 million refs:
Benchmark 1: show-ref: single matching ref (revision = HEAD~)
Time (mean ± σ): 145.5 ms ± 4.5 ms [User: 142.5 ms, System: 2.8 ms]
Range (min … max): 141.3 ms … 177.0 ms 1000 runs
Benchmark 2: show-ref: single matching ref (revision = HEAD)
Time (mean ± σ): 139.0 ms ± 4.7 ms [User: 136.1 ms, System: 2.8 ms]
Range (min … max): 134.2 ms … 182.2 ms 1000 runs
Summary
show-ref: single matching ref (revision = HEAD) ran
1.05 ± 0.05 times faster than show-ref: single matching ref (revision = HEAD~)
This refactoring also allows a subsequent refactoring where we start
reusing memory allocated by the reftable records because we do not need
to release the caller-provided record anymore.
Signed-off-by: Patrick Steinhardt <ps@pks.im>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
75 lines
1.5 KiB
C
75 lines
1.5 KiB
C
/*
|
|
Copyright 2020 Google LLC
|
|
|
|
Use of this source code is governed by a BSD-style
|
|
license that can be found in the LICENSE file or at
|
|
https://developers.google.com/open-source/licenses/bsd
|
|
*/
|
|
|
|
#include "system.h"
|
|
|
|
#include "basics.h"
|
|
#include "constants.h"
|
|
#include "pq.h"
|
|
#include "record.h"
|
|
#include "reftable-tests.h"
|
|
#include "test_framework.h"
|
|
|
|
void merged_iter_pqueue_check(struct merged_iter_pqueue pq)
|
|
{
|
|
int i;
|
|
for (i = 1; i < pq.len; i++) {
|
|
int parent = (i - 1) / 2;
|
|
|
|
EXPECT(pq_less(&pq.heap[parent], &pq.heap[i]));
|
|
}
|
|
}
|
|
|
|
static void test_pq(void)
|
|
{
|
|
struct merged_iter_pqueue pq = { NULL };
|
|
struct reftable_record recs[54];
|
|
int N = ARRAY_SIZE(recs) - 1, i;
|
|
char *last = NULL;
|
|
|
|
for (i = 0; i < N; i++) {
|
|
struct strbuf refname = STRBUF_INIT;
|
|
strbuf_addf(&refname, "%02d", i);
|
|
|
|
reftable_record_init(&recs[i], BLOCK_TYPE_REF);
|
|
recs[i].u.ref.refname = strbuf_detach(&refname, NULL);
|
|
}
|
|
|
|
i = 1;
|
|
do {
|
|
struct pq_entry e = {
|
|
.rec = &recs[i],
|
|
};
|
|
|
|
merged_iter_pqueue_add(&pq, &e);
|
|
merged_iter_pqueue_check(pq);
|
|
|
|
i = (i * 7) % N;
|
|
} while (i != 1);
|
|
|
|
while (!merged_iter_pqueue_is_empty(pq)) {
|
|
struct pq_entry e = merged_iter_pqueue_remove(&pq);
|
|
merged_iter_pqueue_check(pq);
|
|
|
|
EXPECT(reftable_record_type(e.rec) == BLOCK_TYPE_REF);
|
|
if (last)
|
|
EXPECT(strcmp(last, e.rec->u.ref.refname) < 0);
|
|
last = e.rec->u.ref.refname;
|
|
}
|
|
|
|
for (i = 0; i < N; i++)
|
|
reftable_record_release(&recs[i]);
|
|
merged_iter_pqueue_release(&pq);
|
|
}
|
|
|
|
int pq_test_main(int argc, const char *argv[])
|
|
{
|
|
RUN_TEST(test_pq);
|
|
return 0;
|
|
}
|