2017-01-22 17:51:11 +00:00
|
|
|
#include "../git-compat-util.h"
|
|
|
|
|
|
|
|
/*
|
|
|
|
* A merge sort implementation, simplified from the qsort implementation
|
|
|
|
* by Mike Haertel, which is a part of the GNU C Library.
|
|
|
|
* Added context pointer, safety checks and return value.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static void msort_with_tmp(void *b, size_t n, size_t s,
|
|
|
|
int (*cmp)(const void *, const void *, void *),
|
|
|
|
char *t, void *ctx)
|
|
|
|
{
|
|
|
|
char *tmp;
|
|
|
|
char *b1, *b2;
|
|
|
|
size_t n1, n2;
|
|
|
|
|
|
|
|
if (n <= 1)
|
|
|
|
return;
|
|
|
|
|
|
|
|
n1 = n / 2;
|
|
|
|
n2 = n - n1;
|
|
|
|
b1 = b;
|
|
|
|
b2 = (char *)b + (n1 * s);
|
|
|
|
|
|
|
|
msort_with_tmp(b1, n1, s, cmp, t, ctx);
|
|
|
|
msort_with_tmp(b2, n2, s, cmp, t, ctx);
|
|
|
|
|
|
|
|
tmp = t;
|
|
|
|
|
|
|
|
while (n1 > 0 && n2 > 0) {
|
|
|
|
if (cmp(b1, b2, ctx) <= 0) {
|
|
|
|
memcpy(tmp, b1, s);
|
|
|
|
tmp += s;
|
|
|
|
b1 += s;
|
|
|
|
--n1;
|
|
|
|
} else {
|
|
|
|
memcpy(tmp, b2, s);
|
|
|
|
tmp += s;
|
|
|
|
b2 += s;
|
|
|
|
--n2;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (n1 > 0)
|
|
|
|
memcpy(tmp, b1, n1 * s);
|
|
|
|
memcpy(b, t, (n - n2) * s);
|
|
|
|
}
|
|
|
|
|
|
|
|
int git_qsort_s(void *b, size_t n, size_t s,
|
|
|
|
int (*cmp)(const void *, const void *, void *), void *ctx)
|
|
|
|
{
|
|
|
|
const size_t size = st_mult(n, s);
|
compat/qsort_s.c: avoid using potentially unaligned access
The compatibility definition for qsort_s() uses "char buffer[1024]"
on the stack to avoid making malloc() calls for small temporary
space, which essentially hand-rolls alloca().
But the elements of the array being sorted may have alignment needs
more strict than what an array of bytes may have. &buf[0] may be
word aligned, but using the address as if it stores the first
element of an array of a struct, whose first member may need to be
aligned on double-word boundary, would be a no-no.
We could use xalloca() from git-compat-util.h, or alloca() directly
on platforms with HAVE_ALLOCA_H, but let's try using unconditionally
xmalloc() before we know the performance characteristics of the
callers.
It may not make much of an argument to inspect the current callers
and say "it shouldn't matter to any of them", but anyway:
* The one in object-name.c is used to sort potential matches to a
given ambiguous object name prefix in the error path;
* The one in pack-write.c is done once per a pack .idx file being
written to create the reverse index, so (1) the cost of malloc()
overhead is dwarfed by the cost of the packing operation, and (2)
the number of entries being sorted is the number of objects in a
pack;
* The one in ref-filter.c is used by "branch --list", "tag --list",
and "for-each-ref", only once per operation. We sort an array of
pointers with entries, each corresponding to a ref that is shown.
* The one in string-list.c is used by sort_string_list(), which is
way too generic to assume any access patterns, so it may or may
not matter, but I do not care too much ;-)
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2022-01-07 21:30:00 +00:00
|
|
|
char *tmp;
|
2017-01-22 17:51:11 +00:00
|
|
|
|
|
|
|
if (!n)
|
|
|
|
return 0;
|
|
|
|
if (!b || !cmp)
|
|
|
|
return -1;
|
|
|
|
|
compat/qsort_s.c: avoid using potentially unaligned access
The compatibility definition for qsort_s() uses "char buffer[1024]"
on the stack to avoid making malloc() calls for small temporary
space, which essentially hand-rolls alloca().
But the elements of the array being sorted may have alignment needs
more strict than what an array of bytes may have. &buf[0] may be
word aligned, but using the address as if it stores the first
element of an array of a struct, whose first member may need to be
aligned on double-word boundary, would be a no-no.
We could use xalloca() from git-compat-util.h, or alloca() directly
on platforms with HAVE_ALLOCA_H, but let's try using unconditionally
xmalloc() before we know the performance characteristics of the
callers.
It may not make much of an argument to inspect the current callers
and say "it shouldn't matter to any of them", but anyway:
* The one in object-name.c is used to sort potential matches to a
given ambiguous object name prefix in the error path;
* The one in pack-write.c is done once per a pack .idx file being
written to create the reverse index, so (1) the cost of malloc()
overhead is dwarfed by the cost of the packing operation, and (2)
the number of entries being sorted is the number of objects in a
pack;
* The one in ref-filter.c is used by "branch --list", "tag --list",
and "for-each-ref", only once per operation. We sort an array of
pointers with entries, each corresponding to a ref that is shown.
* The one in string-list.c is used by sort_string_list(), which is
way too generic to assume any access patterns, so it may or may
not matter, but I do not care too much ;-)
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2022-01-07 21:30:00 +00:00
|
|
|
tmp = xmalloc(size);
|
|
|
|
msort_with_tmp(b, n, s, cmp, tmp, ctx);
|
|
|
|
free(tmp);
|
2017-01-22 17:51:11 +00:00
|
|
|
return 0;
|
|
|
|
}
|