mirrors/git
1
0
Fork 0
mirror of https://github.com/git/git.git synced 2024-10-28 04:49:43 +01:00
Code Activity

csum-file.c: use unsafe SHA-1 implementation when available

Browse source 
Update hashwrite() and friends to use the unsafe_-variants of hashing
functions, calling for e.g., "the_hash_algo->unsafe_update_fn()" instead
of "the_hash_algo->update_fn()".

These callers only use the_hash_algo to produce a checksum, which we
depend on for data integrity, but not for cryptographic purposes, so
these callers are safe to use the unsafe (non-collision detecting) SHA-1
implementation.

To time this, I took a freshly packed copy of linux.git, and ran the
following with and without the OPENSSL_SHA1_UNSAFE=1 build-knob. Both
versions were compiled with -O3:

    $ git for-each-ref --format='%(objectname)' refs/heads refs/tags >in
    $ valgrind --tool=callgrind ~/src/git/git-pack-objects \
        --revs --stdout --all-progress --use-bitmap-index <in >/dev/null

Without OPENSSL_SHA1_UNSAFE=1 (that is, using the collision-detecting
SHA-1 implementation for both cryptographic and non-cryptographic
purposes), we spend a significant amount of our instruction count in
hashwrite():

    $ callgrind_annotate --inclusive=yes | grep hashwrite | head -n1
    159,998,868,413 (79.42%)  /home/ttaylorr/src/git/csum-file.c:hashwrite [/home/ttaylorr/src/git/git-pack-objects]

, and the resulting "clone" takes 19.219 seconds of wall clock time,
18.94 seconds of user time and 0.28 seconds of system time.

Compiling with OPENSSL_SHA1_UNSAFE=1, we spend ~60% fewer instructions
in hashwrite():

    $ callgrind_annotate --inclusive=yes | grep hashwrite | head -n1
     59,164,001,176 (58.79%)  /home/ttaylorr/src/git/csum-file.c:hashwrite [/home/ttaylorr/src/git/git-pack-objects]

, and generate the resulting "clone" much faster, in only 11.597 seconds
of wall time, 11.37 seconds of user time, and 0.23 seconds of system
time, for a ~40% speed-up.

Signed-off-by: Taylor Blau <me@ttaylorr.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
This commit is contained in:
Taylor Blau 2024-09-26 11:22:53 -04:00 committed by Junio C Hamano
parent 06c92dafb8
commit 1b9e9be8b4
1 changed files with 9 additions and 9 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

18
csum-file.c
View file

@ -50,7 +50,7 @@ void hashflush(struct hashfile *f)
if (offset) { if (offset) {
if (!f->skip_hash) if (!f->skip_hash)
the_hash_algo->update_fn(&f->ctx, f->buffer, offset); the_hash_algo->unsafe_update_fn(&f->ctx, f->buffer, offset);
flush(f, f->buffer, offset); flush(f, f->buffer, offset);
f->offset = 0; f->offset = 0;
} }
@ -73,7 +73,7 @@ int finalize_hashfile(struct hashfile *f, unsigned char *result,
if (f->skip_hash) if (f->skip_hash)
hashclr(f->buffer, the_repository->hash_algo); hashclr(f->buffer, the_repository->hash_algo);
else else
the_hash_algo->final_fn(f->buffer, &f->ctx); the_hash_algo->unsafe_final_fn(f->buffer, &f->ctx);
if (result) if (result)
hashcpy(result, f->buffer, the_repository->hash_algo); hashcpy(result, f->buffer, the_repository->hash_algo);
@ -128,7 +128,7 @@ void hashwrite(struct hashfile *f, const void *buf, unsigned int count)
* f->offset is necessarily zero. * f->offset is necessarily zero.
*/ */
if (!f->skip_hash) if (!f->skip_hash)
the_hash_algo->update_fn(&f->ctx, buf, nr); the_hash_algo->unsafe_update_fn(&f->ctx, buf, nr);
flush(f, buf, nr); flush(f, buf, nr);
} else { } else {
/* /*
@ -174,7 +174,7 @@ static struct hashfile *hashfd_internal(int fd, const char *name,
f->name = name; f->name = name;
f->do_crc = 0; f->do_crc = 0;
f->skip_hash = 0; f->skip_hash = 0;
the_hash_algo->init_fn(&f->ctx); the_hash_algo->unsafe_init_fn(&f->ctx);
f->buffer_len = buffer_len; f->buffer_len = buffer_len;
f->buffer = xmalloc(buffer_len); f->buffer = xmalloc(buffer_len);
@ -208,7 +208,7 @@ void hashfile_checkpoint(struct hashfile *f, struct hashfile_checkpoint *checkpo
{ {
hashflush(f); hashflush(f);
checkpoint->offset = f->total; checkpoint->offset = f->total;
the_hash_algo->clone_fn(&checkpoint->ctx, &f->ctx); the_hash_algo->unsafe_clone_fn(&checkpoint->ctx, &f->ctx);
} }
int hashfile_truncate(struct hashfile *f, struct hashfile_checkpoint *checkpoint) int hashfile_truncate(struct hashfile *f, struct hashfile_checkpoint *checkpoint)
@ -219,7 +219,7 @@ int hashfile_truncate(struct hashfile *f, struct hashfile_checkpoint *checkpoint
lseek(f->fd, offset, SEEK_SET) != offset) lseek(f->fd, offset, SEEK_SET) != offset)
return -1; return -1;
f->total = offset; f->total = offset;
the_hash_algo->clone_fn(&f->ctx, &checkpoint->ctx); the_hash_algo->unsafe_clone_fn(&f->ctx, &checkpoint->ctx);
f->offset = 0; /* hashflush() was called in checkpoint */ f->offset = 0; /* hashflush() was called in checkpoint */
return 0; return 0;
} }
@ -245,9 +245,9 @@ int hashfile_checksum_valid(const unsigned char *data, size_t total_len)
if (total_len < the_hash_algo->rawsz) if (total_len < the_hash_algo->rawsz)
return 0; /* say "too short"? */ return 0; /* say "too short"? */
the_hash_algo->init_fn(&ctx); the_hash_algo->unsafe_init_fn(&ctx);
the_hash_algo->update_fn(&ctx, data, data_len); the_hash_algo->unsafe_update_fn(&ctx, data, data_len);
the_hash_algo->final_fn(got, &ctx); the_hash_algo->unsafe_final_fn(got, &ctx);
return hasheq(got, data + data_len, the_repository->hash_algo); return hasheq(got, data + data_len, the_repository->hash_algo);
} }