2021-10-07 20:25:10 +00:00
|
|
|
/*
|
|
|
|
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 "pq.h"
|
|
|
|
|
|
|
|
#include "reftable-record.h"
|
|
|
|
#include "system.h"
|
|
|
|
#include "basics.h"
|
|
|
|
|
|
|
|
int pq_less(struct pq_entry *a, struct pq_entry *b)
|
|
|
|
{
|
2024-03-04 10:48:59 +00:00
|
|
|
int cmp = reftable_record_cmp(a->rec, b->rec);
|
2021-10-07 20:25:10 +00:00
|
|
|
if (cmp == 0)
|
|
|
|
return a->index > b->index;
|
|
|
|
return cmp < 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
struct pq_entry merged_iter_pqueue_remove(struct merged_iter_pqueue *pq)
|
|
|
|
{
|
|
|
|
int i = 0;
|
|
|
|
struct pq_entry e = pq->heap[0];
|
|
|
|
pq->heap[0] = pq->heap[pq->len - 1];
|
|
|
|
pq->len--;
|
|
|
|
|
|
|
|
i = 0;
|
|
|
|
while (i < pq->len) {
|
|
|
|
int min = i;
|
|
|
|
int j = 2 * i + 1;
|
|
|
|
int k = 2 * i + 2;
|
|
|
|
if (j < pq->len && pq_less(&pq->heap[j], &pq->heap[i])) {
|
|
|
|
min = j;
|
|
|
|
}
|
|
|
|
if (k < pq->len && pq_less(&pq->heap[k], &pq->heap[min])) {
|
|
|
|
min = k;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (min == i) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
SWAP(pq->heap[i], pq->heap[min]);
|
|
|
|
i = min;
|
|
|
|
}
|
|
|
|
|
|
|
|
return e;
|
|
|
|
}
|
|
|
|
|
2022-09-15 03:37:34 +00:00
|
|
|
void merged_iter_pqueue_add(struct merged_iter_pqueue *pq, const struct pq_entry *e)
|
2021-10-07 20:25:10 +00:00
|
|
|
{
|
|
|
|
int i = 0;
|
2022-01-20 15:12:13 +00:00
|
|
|
|
reftable: introduce macros to grow arrays
Throughout the reftable library we have many cases where we need to grow
arrays. In order to avoid too many reallocations, we roughly double the
capacity of the array on each iteration. The resulting code pattern is
duplicated across many sites.
We have similar patterns in our main codebase, which is why we have
eventually introduced an `ALLOC_GROW()` macro to abstract it away and
avoid some code duplication. We cannot easily reuse this macro here
though because `ALLOC_GROW()` uses `REALLOC_ARRAY()`, which in turn will
call realloc(3P) to grow the array. The reftable code is structured as a
library though (even if the boundaries are fuzzy), and one property this
brings with it is that it is possible to plug in your own allocators. So
instead of using realloc(3P), we need to use `reftable_realloc()` that
knows to use the user-provided implementation.
So let's introduce two new macros `REFTABLE_REALLOC_ARRAY()` and
`REFTABLE_ALLOC_GROW()` that mirror what we do in our main codebase,
with two modifications:
- They use `reftable_realloc()`, as explained above.
- They use a different growth factor of `2 * cap + 1` instead of `(cap
+ 16) * 3 / 2`.
The second change is because we know a bit more about the allocation
patterns in the reftable library. In most cases, we end up only having a
handful of items in the array and don't end up growing them. The initial
capacity that our normal growth factor uses (which is 24) would thus end
up over-allocating in a lot of code paths. This effect is measurable:
- Before change:
HEAP SUMMARY:
in use at exit: 671,983 bytes in 152 blocks
total heap usage: 3,843,446 allocs, 3,843,294 frees, 223,761,402 bytes allocated
- After change with a growth factor of `(2 * alloc + 1)`:
HEAP SUMMARY:
in use at exit: 671,983 bytes in 152 blocks
total heap usage: 3,843,446 allocs, 3,843,294 frees, 223,761,410 bytes allocated
- After change with a growth factor of `(alloc + 16)* 2 / 3`:
HEAP SUMMARY:
in use at exit: 671,983 bytes in 152 blocks
total heap usage: 3,833,673 allocs, 3,833,521 frees, 4,728,251,742 bytes allocated
While the total heap usage is roughly the same, we do end up allocating
significantly more bytes with our usual growth factor (in fact, roughly
21 times as many).
Convert the reftable library to use these new macros.
Signed-off-by: Patrick Steinhardt <ps@pks.im>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2024-02-06 06:35:23 +00:00
|
|
|
REFTABLE_ALLOC_GROW(pq->heap, pq->len + 1, pq->cap);
|
2022-09-15 03:37:34 +00:00
|
|
|
pq->heap[pq->len++] = *e;
|
reftable: introduce macros to grow arrays
Throughout the reftable library we have many cases where we need to grow
arrays. In order to avoid too many reallocations, we roughly double the
capacity of the array on each iteration. The resulting code pattern is
duplicated across many sites.
We have similar patterns in our main codebase, which is why we have
eventually introduced an `ALLOC_GROW()` macro to abstract it away and
avoid some code duplication. We cannot easily reuse this macro here
though because `ALLOC_GROW()` uses `REALLOC_ARRAY()`, which in turn will
call realloc(3P) to grow the array. The reftable code is structured as a
library though (even if the boundaries are fuzzy), and one property this
brings with it is that it is possible to plug in your own allocators. So
instead of using realloc(3P), we need to use `reftable_realloc()` that
knows to use the user-provided implementation.
So let's introduce two new macros `REFTABLE_REALLOC_ARRAY()` and
`REFTABLE_ALLOC_GROW()` that mirror what we do in our main codebase,
with two modifications:
- They use `reftable_realloc()`, as explained above.
- They use a different growth factor of `2 * cap + 1` instead of `(cap
+ 16) * 3 / 2`.
The second change is because we know a bit more about the allocation
patterns in the reftable library. In most cases, we end up only having a
handful of items in the array and don't end up growing them. The initial
capacity that our normal growth factor uses (which is 24) would thus end
up over-allocating in a lot of code paths. This effect is measurable:
- Before change:
HEAP SUMMARY:
in use at exit: 671,983 bytes in 152 blocks
total heap usage: 3,843,446 allocs, 3,843,294 frees, 223,761,402 bytes allocated
- After change with a growth factor of `(2 * alloc + 1)`:
HEAP SUMMARY:
in use at exit: 671,983 bytes in 152 blocks
total heap usage: 3,843,446 allocs, 3,843,294 frees, 223,761,410 bytes allocated
- After change with a growth factor of `(alloc + 16)* 2 / 3`:
HEAP SUMMARY:
in use at exit: 671,983 bytes in 152 blocks
total heap usage: 3,833,673 allocs, 3,833,521 frees, 4,728,251,742 bytes allocated
While the total heap usage is roughly the same, we do end up allocating
significantly more bytes with our usual growth factor (in fact, roughly
21 times as many).
Convert the reftable library to use these new macros.
Signed-off-by: Patrick Steinhardt <ps@pks.im>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2024-02-06 06:35:23 +00:00
|
|
|
|
2021-10-07 20:25:10 +00:00
|
|
|
i = pq->len - 1;
|
|
|
|
while (i > 0) {
|
|
|
|
int j = (i - 1) / 2;
|
|
|
|
if (pq_less(&pq->heap[j], &pq->heap[i])) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
SWAP(pq->heap[j], pq->heap[i]);
|
|
|
|
|
|
|
|
i = j;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void merged_iter_pqueue_release(struct merged_iter_pqueue *pq)
|
|
|
|
{
|
|
|
|
FREE_AND_NULL(pq->heap);
|
2024-03-04 10:48:59 +00:00
|
|
|
memset(pq, 0, sizeof(*pq));
|
2021-10-07 20:25:10 +00:00
|
|
|
}
|