mirror of
https://github.com/git/git.git
synced 2024-11-24 10:26:17 +08:00
8380dcd700
When we are looking up an oid in an array, we obviously don't need to write to the array. Let's mark it as const in the function interfaces, as well as in the local variables we use to derference the void pointer (note a few cases use pointers-to-pointers, so we mark everything const). Signed-off-by: Jeff King <peff@peff.net> Signed-off-by: Junio C Hamano <gitster@pobox.com>
130 lines
3.2 KiB
C
130 lines
3.2 KiB
C
#include "cache.h"
|
|
#include "hash-lookup.h"
|
|
|
|
static uint32_t take2(const struct object_id *oid, size_t ofs)
|
|
{
|
|
return ((oid->hash[ofs] << 8) | oid->hash[ofs + 1]);
|
|
}
|
|
|
|
/*
|
|
* Conventional binary search loop looks like this:
|
|
*
|
|
* do {
|
|
* int mi = lo + (hi - lo) / 2;
|
|
* int cmp = "entry pointed at by mi" minus "target";
|
|
* if (!cmp)
|
|
* return (mi is the wanted one)
|
|
* if (cmp > 0)
|
|
* hi = mi; "mi is larger than target"
|
|
* else
|
|
* lo = mi+1; "mi is smaller than target"
|
|
* } while (lo < hi);
|
|
*
|
|
* The invariants are:
|
|
*
|
|
* - When entering the loop, lo points at a slot that is never
|
|
* above the target (it could be at the target), hi points at a
|
|
* slot that is guaranteed to be above the target (it can never
|
|
* be at the target).
|
|
*
|
|
* - We find a point 'mi' between lo and hi (mi could be the same
|
|
* as lo, but never can be the same as hi), and check if it hits
|
|
* the target. There are three cases:
|
|
*
|
|
* - if it is a hit, we are happy.
|
|
*
|
|
* - if it is strictly higher than the target, we update hi with
|
|
* it.
|
|
*
|
|
* - if it is strictly lower than the target, we update lo to be
|
|
* one slot after it, because we allow lo to be at the target.
|
|
*
|
|
* When choosing 'mi', we do not have to take the "middle" but
|
|
* anywhere in between lo and hi, as long as lo <= mi < hi is
|
|
* satisfied. When we somehow know that the distance between the
|
|
* target and lo is much shorter than the target and hi, we could
|
|
* pick mi that is much closer to lo than the midway.
|
|
*/
|
|
/*
|
|
* The table should contain "nr" elements.
|
|
* The oid of element i (between 0 and nr - 1) should be returned
|
|
* by "fn(i, table)".
|
|
*/
|
|
int oid_pos(const struct object_id *oid, const void *table, size_t nr,
|
|
oid_access_fn fn)
|
|
{
|
|
size_t hi = nr;
|
|
size_t lo = 0;
|
|
size_t mi = 0;
|
|
|
|
if (!nr)
|
|
return -1;
|
|
|
|
if (nr != 1) {
|
|
size_t lov, hiv, miv, ofs;
|
|
|
|
for (ofs = 0; ofs < the_hash_algo->rawsz - 2; ofs += 2) {
|
|
lov = take2(fn(0, table), ofs);
|
|
hiv = take2(fn(nr - 1, table), ofs);
|
|
miv = take2(oid, ofs);
|
|
if (miv < lov)
|
|
return -1;
|
|
if (hiv < miv)
|
|
return index_pos_to_insert_pos(nr);
|
|
if (lov != hiv) {
|
|
/*
|
|
* At this point miv could be equal
|
|
* to hiv (but hash could still be higher);
|
|
* the invariant of (mi < hi) should be
|
|
* kept.
|
|
*/
|
|
mi = (nr - 1) * (miv - lov) / (hiv - lov);
|
|
if (lo <= mi && mi < hi)
|
|
break;
|
|
BUG("assertion failed in binary search");
|
|
}
|
|
}
|
|
}
|
|
|
|
do {
|
|
int cmp;
|
|
cmp = oidcmp(fn(mi, table), oid);
|
|
if (!cmp)
|
|
return mi;
|
|
if (cmp > 0)
|
|
hi = mi;
|
|
else
|
|
lo = mi + 1;
|
|
mi = lo + (hi - lo) / 2;
|
|
} while (lo < hi);
|
|
return index_pos_to_insert_pos(lo);
|
|
}
|
|
|
|
int bsearch_hash(const unsigned char *hash, const uint32_t *fanout_nbo,
|
|
const unsigned char *table, size_t stride, uint32_t *result)
|
|
{
|
|
uint32_t hi, lo;
|
|
|
|
hi = ntohl(fanout_nbo[*hash]);
|
|
lo = ((*hash == 0x0) ? 0 : ntohl(fanout_nbo[*hash - 1]));
|
|
|
|
while (lo < hi) {
|
|
unsigned mi = lo + (hi - lo) / 2;
|
|
int cmp = hashcmp(table + mi * stride, hash);
|
|
|
|
if (!cmp) {
|
|
if (result)
|
|
*result = mi;
|
|
return 1;
|
|
}
|
|
if (cmp > 0)
|
|
hi = mi;
|
|
else
|
|
lo = mi + 1;
|
|
}
|
|
|
|
if (result)
|
|
*result = lo;
|
|
return 0;
|
|
}
|