This is an archive of the discontinued Mercurial Phabricator instance.

Differential D2765

xdiff: use int64 for hash table size
ClosedPublic

Authored by quark on Mar 9 2018, 5:54 PM.

Details

Reviewers
indygreg
Group Reviewers
hg-reviewers
Commits
rHGf1ef0e53e628: xdiff: use int64 for hash table size
rHG71fbceb58746: xdiff: use int64 for hash table size
Summary

Follow-up of the previous "long" -> "int64" change. Now xdiff only uses int
for return values and small integers (ex. booleans, shifting score, bits in
hash table size, etc) so it should be able to handle large input.

Diff Detail

Repository
rHG Mercurial
Lint
Lint Skipped
Unit
Unit Tests Skipped

Event Timeline

quark created this revision.Mar 9 2018, 5:54 PM
indygreg accepted this revision.Mar 9 2018, 6:22 PM
This revision is now accepted and ready to land.Mar 9 2018, 6:22 PM
Closed by commit rHG71fbceb58746: xdiff: use int64 for hash table size (authored by quark). · Explain WhyMar 9 2018, 6:24 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 6802

mercurial/thirdparty/xdiff/xprepare.c

static int xdl_optimize_ctxs(xdlclassifier_t *cf, xdfile_t *xdf1, xdfile_t *xdf2); static int xdl_optimize_ctxs(xdlclassifier_t *cf, xdfile_t *xdf1, xdfile_t *xdf2);
static int xdl_init_classifier(xdlclassifier_t *cf, int64_t size, int64_t flags) { static int xdl_init_classifier(xdlclassifier_t *cf, int64_t size, int64_t flags) {
cf->flags = flags; cf->flags = flags;
cf->hbits = xdl_hashbits((unsigned int) size); cf->hbits = xdl_hashbits(size);
cf->hsize = 1 << cf->hbits; cf->hsize = 1 << cf->hbits;
if (xdl_cha_init(&cf->ncha, sizeof(xdlclass_t), size / 4 + 1) < 0) { if (xdl_cha_init(&cf->ncha, sizeof(xdlclass_t), size / 4 + 1) < 0) {
return -1; return -1;
} }
if (!(cf->rchash = (xdlclass_t **) xdl_malloc(cf->hsize * sizeof(xdlclass_t *)))) { if (!(cf->rchash = (xdlclass_t **) xdl_malloc(cf->hsize * sizeof(xdlclass_t *)))) {
recs = NULL; recs = NULL;
if (xdl_cha_init(&xdf->rcha, sizeof(xrecord_t), narec / 4 + 1) < 0) if (xdl_cha_init(&xdf->rcha, sizeof(xrecord_t), narec / 4 + 1) < 0)
goto abort; goto abort;
if (!(recs = (xrecord_t **) xdl_malloc(narec * sizeof(xrecord_t *)))) if (!(recs = (xrecord_t **) xdl_malloc(narec * sizeof(xrecord_t *))))
goto abort; goto abort;
{ {
hbits = xdl_hashbits((unsigned int) narec); hbits = xdl_hashbits(narec);
hsize = 1 << hbits; hsize = 1 << hbits;
if (!(rhash = (xrecord_t **) xdl_malloc(hsize * sizeof(xrecord_t *)))) if (!(rhash = (xrecord_t **) xdl_malloc(hsize * sizeof(xrecord_t *))))
goto abort; goto abort;
memset(rhash, 0, hsize * sizeof(xrecord_t *)); memset(rhash, 0, hsize * sizeof(xrecord_t *));
} }
nrec = 0; nrec = 0;
if ((cur = blk = xdl_mmfile_first(mf, &bsize)) != NULL) { if ((cur = blk = xdl_mmfile_first(mf, &bsize)) != NULL) {

mercurial/thirdparty/xdiff/xutils.h

int64_t xdl_bogosqrt(int64_t n); int64_t xdl_bogosqrt(int64_t n);
int xdl_cha_init(chastore_t *cha, int64_t isize, int64_t icount); int xdl_cha_init(chastore_t *cha, int64_t isize, int64_t icount);
void xdl_cha_free(chastore_t *cha); void xdl_cha_free(chastore_t *cha);
void *xdl_cha_alloc(chastore_t *cha); void *xdl_cha_alloc(chastore_t *cha);
int64_t xdl_guess_lines(mmfile_t *mf, int64_t sample); int64_t xdl_guess_lines(mmfile_t *mf, int64_t sample);
int xdl_recmatch(const char *l1, int64_t s1, const char *l2, int64_t s2); int xdl_recmatch(const char *l1, int64_t s1, const char *l2, int64_t s2);
uint64_t xdl_hash_record(char const **data, char const *top); uint64_t xdl_hash_record(char const **data, char const *top);
unsigned int xdl_hashbits(unsigned int size); unsigned int xdl_hashbits(int64_t size);
#endif /* #if !defined(XUTILS_H) */ #endif /* #if !defined(XUTILS_H) */

mercurial/thirdparty/xdiff/xutils.c

ha += (ha << 5); ha += (ha << 5);
ha ^= (unsigned long) *ptr; ha ^= (unsigned long) *ptr;
} }
*data = ptr < top ? ptr + 1: ptr; *data = ptr < top ? ptr + 1: ptr;
return ha; return ha;
} }
unsigned int xdl_hashbits(unsigned int size) { unsigned int xdl_hashbits(int64_t size) {
unsigned int val = 1, bits = 0; int64_t val = 1;
unsigned int bits = 0;
for (; val < size && bits < CHAR_BIT * sizeof(unsigned int); val <<= 1, bits++); for (; val < size && bits < (int64_t) CHAR_BIT * sizeof(unsigned int); val <<= 1, bits++);
return bits ? bits: 1; return bits ? bits: 1;
} }