ckolivas/lrzip
1
0
Fork 0
mirror of https://github.com/ckolivas/lrzip.git synced 2025-12-06 07:12:00 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity

Fix md5 process bytes to occur at the same time as crc with the same buffer, saving time.

Browse source
This commit is contained in:
Con Kolivas 2011-02-19 10:34:45 +11:00
parent d1a70bbb90
commit 7287ab8a66
2 changed files with 18 additions and 39 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

13
runzip.c
View file

@ -83,6 +83,7 @@ static i64 unzip_literal(void *ss, i64 len, int fd_out, uint32 *cksum)
fatal("Failed to write literal buffer of size %lld\n", stream_read);
*cksum = CrcUpdate(*cksum, buf, stream_read);
md5_process_bytes(buf, stream_read, &control.ctx);
free(buf);
return stream_read;
@ -122,6 +123,7 @@ static i64 unzip_match(void *ss, i64 len, int fd_out, int fd_hist, uint32 *cksum
fatal("Failed to write %d bytes in unzip_match\n", n);
*cksum = CrcUpdate(*cksum, off_buf, n);
md5_process_bytes(off_buf, n, &control.ctx);
len -= n;
off_buf += n;
@ -231,24 +233,15 @@ i64 runzip_fd(int fd_in, int fd_out, int fd_hist, i64 expected_size)
int j;
md5_init_ctx (&control.ctx);
md5_stream = fopen(control.outfile, "r");
if (unlikely(md5_stream == NULL))
fatal("Failed to fdopen md5_stream in runzip_fd\n");
gettimeofday(&start,NULL);
while (total < expected_size) {
while (total < expected_size)
total += runzip_chunk(fd_in, fd_out, fd_hist, expected_size, total);
if (md5_midstream(md5_stream, &control.ctx))
fatal("Failed md5_midstream in runzip_fd\n");
}
gettimeofday(&end,NULL);
print_progress("\nAverage DeCompression Speed: %6.3fMB/s\n",
(total / 1024 / 1024) / (double)((end.tv_sec-start.tv_sec)? : 1));
if (unlikely(fclose(md5_stream)))
fatal("Failed to fclose md5_stream in runzip_fd\n");
md5_finish_ctx (&control.ctx, md5_resblock);
if (HASH_CHECK || VERBOSE) {
print_output("MD5 sum: ");

44
rzip.c
View file

@ -109,7 +109,7 @@ static void round_to_page(i64 *size)
static void remap_low_sb(void)
{
i64 new_offset, md5_off;
i64 new_offset;
new_offset = sb.offset_search;
round_to_page(&new_offset);
@ -122,10 +122,6 @@ static void remap_low_sb(void)
sb.buf_low = (uchar *)mmap(sb.buf_low, sb.size_low, PROT_READ, MAP_SHARED, sb.fd, sb.orig_offset + sb.offset_low);
if (unlikely(sb.buf_low == MAP_FAILED))
fatal("Failed to re mmap in remap_low_sb\n");
print_output("md5read %lld offset_low %lld\n", control.md5_read, sb.offset_low);
md5_off = control.md5_read - sb.offset_low;
md5_process_bytes(sb.buf_low + md5_off, sb.size_low - md5_off, &control.ctx);
control.md5_read += sb.size_low - md5_off;
}
static inline void remap_high_sb(i64 p)
@ -591,10 +587,16 @@ static void hash_search(struct rzip_state *st, double pct_base, double pct_multi
if (p > (i64)cksum_limit) {
i64 i, n = st->chunk_size - p;
uchar *ckbuf = malloc(n);
if (!ckbuf)
fatal("Failed to malloc ckbuf in hash_search\n");
for (i = 0; i < n; i++)
st->cksum = CrcUpdate(st->cksum, get_sb(cksum_limit + i), 1);
memcpy(ckbuf + i, get_sb(cksum_limit + i), 1);
st->cksum = CrcUpdate(st->cksum, ckbuf, n);
md5_process_bytes(ckbuf, n, &control.ctx);
cksum_limit += n;
free(ckbuf);
}
}
@ -606,10 +608,16 @@ static void hash_search(struct rzip_state *st, double pct_base, double pct_multi
if (st->chunk_size > cksum_limit) {
i64 i, n = st->chunk_size - cksum_limit;
uchar *ckbuf = malloc(n);
if (!ckbuf)
fatal("Failed to malloc ckbuf in hash_search\n");
for (i = 0; i < n; i++)
st->cksum = CrcUpdate(st->cksum, get_sb(cksum_limit + i), 1);
memcpy(ckbuf + i, get_sb(cksum_limit + i), 1);
st->cksum = CrcUpdate(st->cksum, ckbuf, n);
md5_process_bytes(ckbuf, n, &control.ctx);
cksum_limit += n;
free(ckbuf);
}
put_literal(st, 0, 0);
@ -669,8 +677,6 @@ static void mmap_stdin(uchar *buf, struct rzip_state *st)
len -= ret;
}
control.st_size += total;
md5_process_bytes(buf, total, &control.ctx);
control.md5_read += total;
}
static void init_sliding_mmap(struct rzip_state *st, int fd_in, i64 offset)
@ -743,7 +749,6 @@ void rzip_fd(int fd_in, int fd_out)
char md5_resblock[MD5_DIGEST_SIZE];
md5_init_ctx (&control.ctx);
control.md5_read = 0;
st = calloc(sizeof(*st), 1);
if (unlikely(!st))
@ -847,8 +852,6 @@ retry:
}
if (st->mmap_size < st->chunk_size)
print_maxverbose("Enabling sliding mmap mode and using mmap of %lld bytes with window of %lld bytes\n", st->mmap_size, st->chunk_size);
md5_process_bytes(sb.buf_low, st->mmap_size, &control.ctx);
control.md5_read += st->mmap_size;
}
print_maxverbose("Succeeded in testing %lld sized mmap for rzip pre-processing\n", st->mmap_size);
@ -912,23 +915,6 @@ retry:
close_streamout_threads();
if (unlikely(!STDIN && control.md5_read < sb.orig_size)) {
/* This happens when the low_sb buffer doesn't map the last
* few bytes because it's less than one page. */
i64 md5_off, len, offset = control.md5_read;
uchar *buf;
round_to_page(&offset);
len = sb.orig_size - offset;
buf = (uchar *)mmap(NULL, len, PROT_READ, MAP_SHARED, sb.fd, offset);
if (unlikely(buf == MAP_FAILED))
fatal("Failed to mmap last md5 calculation in rzip_fd\n");
md5_off = control.md5_read - offset;
md5_process_bytes(buf + md5_off, len - md5_off, &control.ctx);
print_output("\nUpdating md5 size %lld read %lld off %lld len %lld\n", sb.orig_size, control.md5_read, md5_off, len - md5_off);
if (unlikely(munmap(buf, len)))
fatal("Failed to munmap in last md5 calculation in rzip_fd\n");
}
md5_finish_ctx (&control.ctx, md5_resblock);
if (HASH_CHECK || VERBOSE) {
print_output("MD5 sum: ");