facebook
/
zstd
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Add min/max offset to stats

dev
Stella Lau 2017-07-13 15:29:41 -07:00
parent 2b3c7e4199
commit 361c06df75
8 changed files with 386 additions and 560 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

93
contrib/long_distance_matching/ldm.c
View File

@ -1,25 +1,14 @@
#include <stdlib.h> #include <limits.h>
#include <string.h>
#include <stdint.h> #include <stdint.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "ldm.h" #include "ldm.h"
// Insert every (HASH_ONLY_EVERY + 1) into the hash table. // Insert every (HASH_ONLY_EVERY + 1) into the hash table.
#define HASH_ONLY_EVERY 0 #define HASH_ONLY_EVERY 0
#define LDM_MEMORY_USAGE 22
#define LDM_HASHLOG (LDM_MEMORY_USAGE-2)
#define LDM_HASHTABLESIZE (1 << (LDM_MEMORY_USAGE))
#define LDM_HASHTABLESIZE_U32 ((LDM_HASHTABLESIZE) >> 2)
#define LDM_OFFSET_SIZE 4
#define WINDOW_SIZE (1 << 29)
//These should be multiples of four.
#define LDM_HASH_LENGTH 8
#define ML_BITS 4 #define ML_BITS 4
#define ML_MASK ((1U<<ML_BITS)-1) #define ML_MASK ((1U<<ML_BITS)-1)
#define RUN_BITS (8-ML_BITS) #define RUN_BITS (8-ML_BITS)
@ -34,19 +23,24 @@ struct LDM_hashEntry {
offset_t offset; offset_t offset;
}; };
// TODO: Add offset histogram by powers of two
// TODO: Scanning speed
// TODO: Memory usage
struct LDM_compressStats { struct LDM_compressStats {
U32 numMatches; U32 numMatches;
U32 totalMatchLength; U64 totalMatchLength;
U32 totalLiteralLength; U64 totalLiteralLength;
U64 totalOffset; U64 totalOffset;
U32 minOffset, maxOffset;
U32 numCollisions; U32 numCollisions;
U32 numHashInserts; U32 numHashInserts;
}; };
struct LDM_CCtx { struct LDM_CCtx {
size_t isize; /* Input size */ U64 isize; /* Input size */
size_t maxOSize; /* Maximum output size */ U64 maxOSize; /* Maximum output size */
const BYTE *ibase; /* Base of input */ const BYTE *ibase; /* Base of input */
const BYTE *ip; /* Current input position */ const BYTE *ip; /* Current input position */
@ -84,26 +78,8 @@ struct LDM_CCtx {
const BYTE *DEBUG_setNextHash; const BYTE *DEBUG_setNextHash;
}; };
void LDM_printCompressStats(const LDM_compressStats *stats, void LDM_outputHashtableOccupancy(
const LDM_hashEntry *hashTable, const LDM_hashEntry *hashTable, U32 hashTableSize) {
U32 hashTableSize) {
printf("=====================\n");
printf("Compression statistics\n");
printf("Total number of matches: %u\n", stats->numMatches);
printf("Average match length: %.1f\n", ((double)stats->totalMatchLength) /
(double)stats->numMatches);
printf("Average literal length: %.1f\n",
((double)stats->totalLiteralLength) / (double)stats->numMatches);
printf("Average offset length: %.1f\n",
((double)stats->totalOffset) / (double)stats->numMatches);
printf("Num collisions, num hash inserts, %% collisions: %u, %u, %.3f\n",
stats->numCollisions, stats->numHashInserts,
stats->numHashInserts == 0 ?
1.0 : (100.0 * (double)stats->numCollisions) /
(double)stats->numHashInserts);
// Output occupancy of hash table.
{
U32 i = 0; U32 i = 0;
U32 ctr = 0; U32 ctr = 0;
for (; i < hashTableSize; i++) { for (; i < hashTableSize; i++) {
@ -111,12 +87,31 @@ void LDM_printCompressStats(const LDM_compressStats *stats,
ctr++; ctr++;
} }
} }
printf("Hash table size, empty slots, %% empty: %u %u %.3f\n", printf("Hash table size, empty slots, %% empty: %u, %u, %.3f\n",
hashTableSize, ctr, hashTableSize, ctr,
100.0 * (double)(ctr) / (double)hashTableSize); 100.0 * (double)(ctr) / (double)hashTableSize);
} }
void LDM_printCompressStats(const LDM_compressStats *stats) {
printf("=====================\n"); printf("=====================\n");
printf("Compression statistics\n");
//TODO: compute percentage matched?
printf("num matches, total match length: %u, %llu\n",
stats->numMatches,
stats->totalMatchLength);
printf("avg match length: %.1f\n", ((double)stats->totalMatchLength) /
(double)stats->numMatches);
printf("avg literal length: %.1f\n",
((double)stats->totalLiteralLength) / (double)stats->numMatches);
printf("avg offset length: %.1f\n",
((double)stats->totalOffset) / (double)stats->numMatches);
printf("min offset, max offset: %u %u\n",
stats->minOffset, stats->maxOffset);
printf("num collisions, num hash inserts, %% collisions: %u, %u, %.3f\n",
stats->numCollisions, stats->numHashInserts,
stats->numHashInserts == 0 ?
1.0 : (100.0 * (double)stats->numCollisions) /
(double)stats->numHashInserts);
} }
int LDM_isValidMatch(const BYTE *pIn, const BYTE *pMatch) { int LDM_isValidMatch(const BYTE *pIn, const BYTE *pMatch) {
@ -219,8 +214,8 @@ static void setNextHash(LDM_CCtx *cctx) {
// cctx->nextSum = getChecksum((const char *)cctx->nextIp, LDM_HASH_LENGTH); // cctx->nextSum = getChecksum((const char *)cctx->nextIp, LDM_HASH_LENGTH);
cctx->nextSum = updateChecksum( cctx->nextSum = updateChecksum(
cctx->lastSum, LDM_HASH_LENGTH, cctx->lastSum, LDM_HASH_LENGTH,
(cctx->lastPosHashed)[0], cctx->lastPosHashed[0],
(cctx->lastPosHashed)[LDM_HASH_LENGTH]); cctx->lastPosHashed[LDM_HASH_LENGTH]);
cctx->nextPosHashed = cctx->nextIp; cctx->nextPosHashed = cctx->nextIp;
cctx->nextHash = checksumToHash(cctx->nextSum); cctx->nextHash = checksumToHash(cctx->nextSum);
@ -243,7 +238,7 @@ static void putHashOfCurrentPositionFromHash(
LDM_CCtx *cctx, hash_t hash, U32 sum) { LDM_CCtx *cctx, hash_t hash, U32 sum) {
#ifdef COMPUTE_STATS #ifdef COMPUTE_STATS
if (cctx->stats.numHashInserts < LDM_HASHTABLESIZE_U32) { if (cctx->stats.numHashInserts < LDM_HASHTABLESIZE_U32) {
offset_t offset = (cctx->hashTable)[hash].offset; offset_t offset = cctx->hashTable[hash].offset;
cctx->stats.numHashInserts++; cctx->stats.numHashInserts++;
if (offset != 0 && !LDM_isValidMatch(cctx->ip, offset + cctx->ibase)) { if (offset != 0 && !LDM_isValidMatch(cctx->ip, offset + cctx->ibase)) {
cctx->stats.numCollisions++; cctx->stats.numCollisions++;
@ -254,8 +249,8 @@ static void putHashOfCurrentPositionFromHash(
// Hash only every HASH_ONLY_EVERY times, based on cctx->ip. // Hash only every HASH_ONLY_EVERY times, based on cctx->ip.
// Note: this works only when cctx->step is 1. // Note: this works only when cctx->step is 1.
if (((cctx->ip - cctx->ibase) & HASH_ONLY_EVERY) == HASH_ONLY_EVERY) { if (((cctx->ip - cctx->ibase) & HASH_ONLY_EVERY) == HASH_ONLY_EVERY) {
(cctx->hashTable)[hash] = const LDM_hashEntry entry = { cctx->ip - cctx->ibase };
(LDM_hashEntry){ (offset_t)(cctx->ip - cctx->ibase) }; cctx->hashTable[hash] = entry;
} }
cctx->lastPosHashed = cctx->ip; cctx->lastPosHashed = cctx->ip;
@ -347,6 +342,7 @@ void LDM_initializeCCtx(LDM_CCtx *cctx,
memset(&(cctx->stats), 0, sizeof(cctx->stats)); memset(&(cctx->stats), 0, sizeof(cctx->stats));
memset(cctx->hashTable, 0, sizeof(cctx->hashTable)); memset(cctx->hashTable, 0, sizeof(cctx->hashTable));
cctx->stats.minOffset = UINT_MAX;
cctx->lastPosHashed = NULL; cctx->lastPosHashed = NULL;
@ -493,6 +489,10 @@ size_t LDM_compress(const void *src, size_t srcSize,
cctx.stats.totalLiteralLength += literalLength; cctx.stats.totalLiteralLength += literalLength;
cctx.stats.totalOffset += offset; cctx.stats.totalOffset += offset;
cctx.stats.totalMatchLength += matchLength + LDM_MIN_MATCH_LENGTH; cctx.stats.totalMatchLength += matchLength + LDM_MIN_MATCH_LENGTH;
cctx.stats.minOffset =
offset < cctx.stats.minOffset ? offset : cctx.stats.minOffset;
cctx.stats.maxOffset =
offset > cctx.stats.maxOffset ? offset : cctx.stats.maxOffset;
#endif #endif
LDM_outputBlock(&cctx, literalLength, offset, matchLength); LDM_outputBlock(&cctx, literalLength, offset, matchLength);
@ -523,7 +523,8 @@ _last_literals:
} }
#ifdef COMPUTE_STATS #ifdef COMPUTE_STATS
LDM_printCompressStats(&cctx.stats, cctx.hashTable, LDM_HASHTABLESIZE_U32); LDM_printCompressStats(&cctx.stats);
LDM_outputHashtableOccupancy(cctx.hashTable, LDM_HASHTABLESIZE_U32);
#endif #endif
return (cctx.op - (const BYTE *)cctx.obase); return (cctx.op - (const BYTE *)cctx.obase);

24
contrib/long_distance_matching/ldm.h
View File

@ -8,9 +8,19 @@
#define LDM_COMPRESS_SIZE 8 #define LDM_COMPRESS_SIZE 8
#define LDM_DECOMPRESS_SIZE 8 #define LDM_DECOMPRESS_SIZE 8
#define LDM_HEADER_SIZE ((LDM_COMPRESS_SIZE)+(LDM_DECOMPRESS_SIZE)) #define LDM_HEADER_SIZE ((LDM_COMPRESS_SIZE)+(LDM_DECOMPRESS_SIZE))
#define LDM_OFFSET_SIZE 4
// This should be a multiple of four. // Defines the size of the hash table.
#define LDM_MEMORY_USAGE 22
#define LDM_HASHLOG (LDM_MEMORY_USAGE-2)
#define LDM_HASHTABLESIZE (1 << (LDM_MEMORY_USAGE))
#define LDM_HASHTABLESIZE_U32 ((LDM_HASHTABLESIZE) >> 2)
#define WINDOW_SIZE (1 << 25)
//These should be multiples of four.
#define LDM_MIN_MATCH_LENGTH 8 #define LDM_MIN_MATCH_LENGTH 8
#define LDM_HASH_LENGTH 8
typedef U32 offset_t; typedef U32 offset_t;
typedef U32 hash_t; typedef U32 hash_t;
@ -55,12 +65,18 @@ size_t LDM_compress(const void *src, size_t srcSize,
void LDM_initializeCCtx(LDM_CCtx *cctx, void LDM_initializeCCtx(LDM_CCtx *cctx,
const void *src, size_t srcSize, const void *src, size_t srcSize,
void *dst, size_t maxDstSize); void *dst, size_t maxDstSize);
/**
* Prints the percentage of the hash table occupied (where occupied is defined
* as the entry being non-zero).
*/
void LDM_outputHashtableOccupancy(const LDM_hashEntry *hashTable,
U32 hashTableSize);
/** /**
* Outputs compression statistics to stdout. * Outputs compression statistics to stdout.
*/ */
void LDM_printCompressStats(const LDM_compressStats *stats, void LDM_printCompressStats(const LDM_compressStats *stats);
const LDM_hashEntry *hashTable,
U32 hashTableSize);
/** /**
* Checks whether the LDM_MIN_MATCH_LENGTH bytes from p are the same as the * Checks whether the LDM_MIN_MATCH_LENGTH bytes from p are the same as the
* LDM_MIN_MATCH_LENGTH bytes from match. * LDM_MIN_MATCH_LENGTH bytes from match.

14
contrib/long_distance_matching/versions/v0.5/Makefile
View File

@ -1,5 +1,15 @@
# ################################################################
# Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
# All rights reserved.
#
# This source code is licensed under the BSD-style license found in the
# LICENSE file in the root directory of this source tree. An additional grant
# of patent rights can be found in the PATENTS file in the same directory.
# ################################################################
# This Makefile presumes libzstd is installed, using `sudo make install` # This Makefile presumes libzstd is installed, using `sudo make install`
CPPFLAGS+= -I../../../../lib/common
CFLAGS ?= -O3 CFLAGS ?= -O3
DEBUGFLAGS = -Wall -Wextra -Wcast-qual -Wcast-align -Wshadow \ DEBUGFLAGS = -Wall -Wextra -Wcast-qual -Wcast-align -Wshadow \
-Wstrict-aliasing=1 -Wswitch-enum -Wdeclaration-after-statement \ -Wstrict-aliasing=1 -Wswitch-enum -Wdeclaration-after-statement \
@ -17,11 +27,11 @@ default: all
all: main-ldm all: main-ldm
main-ldm : util.c ldm.c main-ldm.c main-ldm : ldm.c main-ldm.c
$(CC) $(CPPFLAGS) $(CFLAGS) $^ $(LDFLAGS) -o $@ $(CC) $(CPPFLAGS) $(CFLAGS) $^ $(LDFLAGS) -o $@
clean: clean:
@rm -f core *.o tmp* result* *.ldm *.ldm.dec \ @rm -f core *.o tmp* result* *.ldm *.ldm.dec \
main-ldm main main-ldm
@echo Cleaning completed @echo Cleaning completed

322
contrib/long_distance_matching/versions/v0.5/ldm.c
View File

@ -1,63 +1,46 @@
#include <stdlib.h> #include <limits.h>
#include <string.h>
#include <stdint.h> #include <stdint.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "ldm.h" #include "ldm.h"
#include "util.h"
// Insert every (HASH_ONLY_EVERY + 1) into the hash table. // Insert every (HASH_ONLY_EVERY + 1) into the hash table.
#define HASH_ONLY_EVERY 0 #define HASH_ONLY_EVERY 0
#define LDM_MEMORY_USAGE 20
#define LDM_HASHLOG (LDM_MEMORY_USAGE-2)
#define LDM_HASHTABLESIZE (1 << (LDM_MEMORY_USAGE))
#define LDM_HASHTABLESIZE_U32 ((LDM_HASHTABLESIZE) >> 2)
#define LDM_OFFSET_SIZE 4
#define WINDOW_SIZE (1 << 20)
//These should be multiples of four.
#define LDM_HASH_LENGTH 4
#define MINMATCH 4
#define ML_BITS 4 #define ML_BITS 4
#define ML_MASK ((1U<<ML_BITS)-1) #define ML_MASK ((1U<<ML_BITS)-1)
#define RUN_BITS (8-ML_BITS) #define RUN_BITS (8-ML_BITS)
#define RUN_MASK ((1U<<RUN_BITS)-1) #define RUN_MASK ((1U<<RUN_BITS)-1)
#define COMPUTE_STATS #define COMPUTE_STATS
#define CHECKSUM_CHAR_OFFSET 0
//#define RUN_CHECKS //#define RUN_CHECKS
//#define LDM_DEBUG //#define LDM_DEBUG
typedef uint8_t BYTE; struct LDM_hashEntry {
typedef uint16_t U16;
typedef uint32_t U32;
typedef int32_t S32;
typedef uint64_t U64;
typedef uint32_t offset_t;
typedef uint32_t hash_t;
typedef signed char schar;
typedef struct hashEntry {
offset_t offset; offset_t offset;
} hashEntry; };
typedef struct LDM_compressStats { // TODO: Add offset histogram by powers of two
// TODO: Scanning speed
// TODO: Memory usage
struct LDM_compressStats {
U32 numMatches; U32 numMatches;
U32 totalMatchLength; U64 totalMatchLength;
U32 totalLiteralLength; U64 totalLiteralLength;
U64 totalOffset; U64 totalOffset;
U32 minOffset, maxOffset;
U32 numCollisions; U32 numCollisions;
U32 numHashInserts; U32 numHashInserts;
} LDM_compressStats; };
typedef struct LDM_CCtx { struct LDM_CCtx {
size_t isize; /* Input size */ U64 isize; /* Input size */
size_t maxOSize; /* Maximum output size */ U64 maxOSize; /* Maximum output size */
const BYTE *ibase; /* Base of input */ const BYTE *ibase; /* Base of input */
const BYTE *ip; /* Current input position */ const BYTE *ip; /* Current input position */
@ -78,7 +61,7 @@ typedef struct LDM_CCtx {
LDM_compressStats stats; /* Compression statistics */ LDM_compressStats stats; /* Compression statistics */
hashEntry hashTable[LDM_HASHTABLESIZE_U32]; LDM_hashEntry hashTable[LDM_HASHTABLESIZE_U32];
const BYTE *lastPosHashed; /* Last position hashed */ const BYTE *lastPosHashed; /* Last position hashed */
hash_t lastHash; /* Hash corresponding to lastPosHashed */ hash_t lastHash; /* Hash corresponding to lastPosHashed */
@ -93,77 +76,66 @@ typedef struct LDM_CCtx {
// DEBUG // DEBUG
const BYTE *DEBUG_setNextHash; const BYTE *DEBUG_setNextHash;
} LDM_CCtx; };
#ifdef COMPUTE_STATS void LDM_outputHashtableOccupancy(
/** const LDM_hashEntry *hashTable, U32 hashTableSize) {
* Outputs compression statistics. U32 i = 0;
*/ U32 ctr = 0;
static void printCompressStats(const LDM_CCtx *cctx) { for (; i < hashTableSize; i++) {
const LDM_compressStats *stats = &(cctx->stats); if (hashTable[i].offset == 0) {
ctr++;
}
}
printf("Hash table size, empty slots, %% empty: %u, %u, %.3f\n",
hashTableSize, ctr,
100.0 * (double)(ctr) / (double)hashTableSize);
}
void LDM_printCompressStats(const LDM_compressStats *stats) {
printf("=====================\n"); printf("=====================\n");
printf("Compression statistics\n"); printf("Compression statistics\n");
printf("Total number of matches: %u\n", stats->numMatches); //TODO: compute percentage matched?
printf("Average match length: %.1f\n", ((double)stats->totalMatchLength) / printf("num matches, total match length: %u, %llu\n",
stats->numMatches,
stats->totalMatchLength);
printf("avg match length: %.1f\n", ((double)stats->totalMatchLength) /
(double)stats->numMatches); (double)stats->numMatches);
printf("Average literal length: %.1f\n", printf("avg literal length: %.1f\n",
((double)stats->totalLiteralLength) / (double)stats->numMatches); ((double)stats->totalLiteralLength) / (double)stats->numMatches);
printf("Average offset length: %.1f\n", printf("avg offset length: %.1f\n",
((double)stats->totalOffset) / (double)stats->numMatches); ((double)stats->totalOffset) / (double)stats->numMatches);
printf("Num collisions, num hash inserts, %% collisions: %u, %u, %.3f\n", printf("min offset, max offset: %u %u\n",
stats->minOffset, stats->maxOffset);
printf("num collisions, num hash inserts, %% collisions: %u, %u, %.3f\n",
stats->numCollisions, stats->numHashInserts, stats->numCollisions, stats->numHashInserts,
stats->numHashInserts == 0 ? stats->numHashInserts == 0 ?
1.0 : (100.0 * (double)stats->numCollisions) / 1.0 : (100.0 * (double)stats->numCollisions) /
(double)stats->numHashInserts); (double)stats->numHashInserts);
// Output occupancy of hash table.
{
U32 i = 0;
U32 ctr = 0;
for (; i < LDM_HASHTABLESIZE_U32; i++) {
if ((cctx->hashTable)[i].offset == 0) {
ctr++;
}
}
printf("Hash table size, empty slots, %% empty: %u %u %.3f\n",
LDM_HASHTABLESIZE_U32, ctr,
100.0 * (double)(ctr) / (double)LDM_HASHTABLESIZE_U32);
}
printf("=====================\n");
} }
#endif
/** int LDM_isValidMatch(const BYTE *pIn, const BYTE *pMatch) {
* Checks whether the MINMATCH bytes from p are the same as the MINMATCH
* bytes from match.
*
* This assumes MINMATCH is a multiple of four.
*
* Return 1 if valid, 0 otherwise.
*/
static int LDM_isValidMatch(const BYTE *p, const BYTE *match) {
/* /*
if (memcmp(p, match, MINMATCH) == 0) { if (memcmp(pIn, pMatch, LDM_MIN_MATCH_LENGTH) == 0) {
return 1; return 1;
} }
return 0; return 0;
*/ */
//TODO: This seems to be faster for some reason? //TODO: This seems to be faster for some reason?
U16 lengthLeft = MINMATCH; U32 lengthLeft = LDM_MIN_MATCH_LENGTH;
const BYTE *curP = p; const BYTE *curIn = pIn;
const BYTE *curMatch = match; const BYTE *curMatch = pMatch;
for (; lengthLeft >= 8; lengthLeft -= 8) { for (; lengthLeft >= 8; lengthLeft -= 8) {
if (LDM_read64(curP) != LDM_read64(curMatch)) { if (MEM_read64(curIn) != MEM_read64(curMatch)) {
return 0; return 0;
} }
curP += 8; curIn += 8;
curMatch += 8; curMatch += 8;
} }
if (lengthLeft > 0) { if (lengthLeft > 0) {
return (LDM_read32(curP) == LDM_read32(curMatch)); return (MEM_read32(curIn) == MEM_read32(curMatch));
} }
return 1; return 1;
} }
@ -183,19 +155,21 @@ static hash_t checksumToHash(U32 sum) {
* b(k,l) = \sum_{i = k}^l ((l - i + 1) * x_i) (mod M) * b(k,l) = \sum_{i = k}^l ((l - i + 1) * x_i) (mod M)
* checksum(k,l) = a(k,l) + 2^{16} * b(k,l) * checksum(k,l) = a(k,l) + 2^{16} * b(k,l)
*/ */
static U32 getChecksum(const char *data, U32 len) { static U32 getChecksum(const BYTE *buf, U32 len) {
U32 i; U32 i;
U32 s1, s2; U32 s1, s2;
const schar *buf = (const schar *)data;
s1 = s2 = 0; s1 = s2 = 0;
for (i = 0; i < (len - 4); i += 4) { for (i = 0; i < (len - 4); i += 4) {
s2 += (4 * (s1 + buf[i])) + (3 * buf[i + 1]) + s2 += (4 * (s1 + buf[i])) + (3 * buf[i + 1]) +
(2 * buf[i + 2]) + (buf[i + 3]); (2 * buf[i + 2]) + (buf[i + 3]) +
s1 += buf[i] + buf[i + 1] + buf[i + 2] + buf[i + 3]; (10 * CHECKSUM_CHAR_OFFSET);
s1 += buf[i] + buf[i + 1] + buf[i + 2] + buf[i + 3] +
+ (4 * CHECKSUM_CHAR_OFFSET);
} }
for(; i < len; i++) { for(; i < len; i++) {
s1 += buf[i]; s1 += buf[i] + CHECKSUM_CHAR_OFFSET;
s2 += s1; s2 += s1;
} }
return (s1 & 0xffff) + (s2 << 16); return (s1 & 0xffff) + (s2 << 16);
@ -211,9 +185,9 @@ static U32 getChecksum(const char *data, U32 len) {
* Thus toRemove should correspond to data[0]. * Thus toRemove should correspond to data[0].
*/ */
static U32 updateChecksum(U32 sum, U32 len, static U32 updateChecksum(U32 sum, U32 len,
schar toRemove, schar toAdd) { BYTE toRemove, BYTE toAdd) {
U32 s1 = (sum & 0xffff) - toRemove + toAdd; U32 s1 = (sum & 0xffff) - toRemove + toAdd;
U32 s2 = (sum >> 16) - (toRemove * len) + s1; U32 s2 = (sum >> 16) - ((toRemove + CHECKSUM_CHAR_OFFSET) * len) + s1;
return (s1 & 0xffff) + (s2 << 16); return (s1 & 0xffff) + (s2 << 16);
} }
@ -240,13 +214,13 @@ static void setNextHash(LDM_CCtx *cctx) {
// cctx->nextSum = getChecksum((const char *)cctx->nextIp, LDM_HASH_LENGTH); // cctx->nextSum = getChecksum((const char *)cctx->nextIp, LDM_HASH_LENGTH);
cctx->nextSum = updateChecksum( cctx->nextSum = updateChecksum(
cctx->lastSum, LDM_HASH_LENGTH, cctx->lastSum, LDM_HASH_LENGTH,
(schar)((cctx->lastPosHashed)[0]), cctx->lastPosHashed[0],
(schar)((cctx->lastPosHashed)[LDM_HASH_LENGTH])); cctx->lastPosHashed[LDM_HASH_LENGTH]);
cctx->nextPosHashed = cctx->nextIp; cctx->nextPosHashed = cctx->nextIp;
cctx->nextHash = checksumToHash(cctx->nextSum); cctx->nextHash = checksumToHash(cctx->nextSum);
#ifdef RUN_CHECKS #ifdef RUN_CHECKS
check = getChecksum((const char *)cctx->nextIp, LDM_HASH_LENGTH); check = getChecksum(cctx->nextIp, LDM_HASH_LENGTH);
if (check != cctx->nextSum) { if (check != cctx->nextSum) {
printf("CHECK: setNextHash failed %u %u\n", check, cctx->nextSum); printf("CHECK: setNextHash failed %u %u\n", check, cctx->nextSum);
@ -264,7 +238,7 @@ static void putHashOfCurrentPositionFromHash(
LDM_CCtx *cctx, hash_t hash, U32 sum) { LDM_CCtx *cctx, hash_t hash, U32 sum) {
#ifdef COMPUTE_STATS #ifdef COMPUTE_STATS
if (cctx->stats.numHashInserts < LDM_HASHTABLESIZE_U32) { if (cctx->stats.numHashInserts < LDM_HASHTABLESIZE_U32) {
offset_t offset = (cctx->hashTable)[hash].offset; offset_t offset = cctx->hashTable[hash].offset;
cctx->stats.numHashInserts++; cctx->stats.numHashInserts++;
if (offset != 0 && !LDM_isValidMatch(cctx->ip, offset + cctx->ibase)) { if (offset != 0 && !LDM_isValidMatch(cctx->ip, offset + cctx->ibase)) {
cctx->stats.numCollisions++; cctx->stats.numCollisions++;
@ -275,7 +249,8 @@ static void putHashOfCurrentPositionFromHash(
// Hash only every HASH_ONLY_EVERY times, based on cctx->ip. // Hash only every HASH_ONLY_EVERY times, based on cctx->ip.
// Note: this works only when cctx->step is 1. // Note: this works only when cctx->step is 1.
if (((cctx->ip - cctx->ibase) & HASH_ONLY_EVERY) == HASH_ONLY_EVERY) { if (((cctx->ip - cctx->ibase) & HASH_ONLY_EVERY) == HASH_ONLY_EVERY) {
(cctx->hashTable)[hash] = (hashEntry){ (offset_t)(cctx->ip - cctx->ibase) }; const LDM_hashEntry entry = { cctx->ip - cctx->ibase };
cctx->hashTable[hash] = entry;
} }
cctx->lastPosHashed = cctx->ip; cctx->lastPosHashed = cctx->ip;
@ -303,7 +278,7 @@ static void LDM_updateLastHashFromNextHash(LDM_CCtx *cctx) {
* Insert hash of the current position into the hash table. * Insert hash of the current position into the hash table.
*/ */
static void LDM_putHashOfCurrentPosition(LDM_CCtx *cctx) { static void LDM_putHashOfCurrentPosition(LDM_CCtx *cctx) {
U32 sum = getChecksum((const char *)cctx->ip, LDM_HASH_LENGTH); U32 sum = getChecksum(cctx->ip, LDM_HASH_LENGTH);
hash_t hash = checksumToHash(sum); hash_t hash = checksumToHash(sum);
#ifdef RUN_CHECKS #ifdef RUN_CHECKS
@ -323,38 +298,31 @@ static const BYTE *getPositionOnHash(LDM_CCtx *cctx, hash_t hash) {
return cctx->hashTable[hash].offset + cctx->ibase; return cctx->hashTable[hash].offset + cctx->ibase;
} }
/** U32 LDM_countMatchLength(const BYTE *pIn, const BYTE *pMatch,
* Counts the number of bytes that match from pIn and pMatch,
* up to pInLimit.
*
* TODO: make more efficient.
*/
static unsigned countMatchLength(const BYTE *pIn, const BYTE *pMatch,
const BYTE *pInLimit) { const BYTE *pInLimit) {
const BYTE * const pStart = pIn; const BYTE * const pStart = pIn;
while (pIn < pInLimit - 1) { while (pIn < pInLimit - 1) {
BYTE const diff = LDM_readByte(pMatch) ^ LDM_readByte(pIn); BYTE const diff = (*pMatch) ^ *(pIn);
if (!diff) { if (!diff) {
pIn++; pIn++;
pMatch++; pMatch++;
continue; continue;
} }
return (unsigned)(pIn - pStart); return (U32)(pIn - pStart);
} }
return (unsigned)(pIn - pStart); return (U32)(pIn - pStart);
} }
void LDM_readHeader(const void *src, size_t *compressSize, void LDM_readHeader(const void *src, U64 *compressedSize,
size_t *decompressSize) { U64 *decompressedSize) {
const U32 *ip = (const U32 *)src; const BYTE *ip = (const BYTE *)src;
*compressSize = *ip++; *compressedSize = MEM_readLE64(ip);
*decompressSize = *ip; ip += sizeof(U64);
*decompressedSize = MEM_readLE64(ip);
// ip += sizeof(U64);
} }
/** void LDM_initializeCCtx(LDM_CCtx *cctx,
* Initialize a compression context.
*/
static void initializeCCtx(LDM_CCtx *cctx,
const void *src, size_t srcSize, const void *src, size_t srcSize,
void *dst, size_t maxDstSize) { void *dst, size_t maxDstSize) {
cctx->isize = srcSize; cctx->isize = srcSize;
@ -365,7 +333,7 @@ static void initializeCCtx(LDM_CCtx *cctx,
cctx->iend = cctx->ibase + srcSize; cctx->iend = cctx->ibase + srcSize;
cctx->ihashLimit = cctx->iend - LDM_HASH_LENGTH; cctx->ihashLimit = cctx->iend - LDM_HASH_LENGTH;
cctx->imatchLimit = cctx->iend - MINMATCH; cctx->imatchLimit = cctx->iend - LDM_MIN_MATCH_LENGTH;
cctx->obase = (BYTE *)dst; cctx->obase = (BYTE *)dst;
cctx->op = (BYTE *)dst; cctx->op = (BYTE *)dst;
@ -374,6 +342,7 @@ static void initializeCCtx(LDM_CCtx *cctx,
memset(&(cctx->stats), 0, sizeof(cctx->stats)); memset(&(cctx->stats), 0, sizeof(cctx->stats));
memset(cctx->hashTable, 0, sizeof(cctx->hashTable)); memset(cctx->hashTable, 0, sizeof(cctx->hashTable));
cctx->stats.minOffset = UINT_MAX;
cctx->lastPosHashed = NULL; cctx->lastPosHashed = NULL;
@ -416,61 +385,65 @@ static int LDM_findBestMatch(LDM_CCtx *cctx, const BYTE **match) {
return 0; return 0;
} }
/** void LDM_encodeLiteralLengthAndLiterals(
* Write current block (literals, literal length, match offset, LDM_CCtx *cctx, BYTE *pToken, const U32 literalLength) {
* match length).
*
* Update input pointer, inserting hashes into hash table along the way.
*/
static void outputBlock(LDM_CCtx *cctx,
unsigned const literalLength,
unsigned const offset,
unsigned const matchLength) {
BYTE *token = cctx->op++;
/* Encode the literal length. */ /* Encode the literal length. */
if (literalLength >= RUN_MASK) { if (literalLength >= RUN_MASK) {
int len = (int)literalLength - RUN_MASK; int len = (int)literalLength - RUN_MASK;
*token = (RUN_MASK << ML_BITS); *pToken = (RUN_MASK << ML_BITS);
for (; len >= 255; len -= 255) { for (; len >= 255; len -= 255) {
*(cctx->op)++ = 255; *(cctx->op)++ = 255;
} }
*(cctx->op)++ = (BYTE)len; *(cctx->op)++ = (BYTE)len;
} else { } else {
*token = (BYTE)(literalLength << ML_BITS); *pToken = (BYTE)(literalLength << ML_BITS);
} }
/* Encode the literals. */ /* Encode the literals. */
memcpy(cctx->op, cctx->anchor, literalLength); memcpy(cctx->op, cctx->anchor, literalLength);
cctx->op += literalLength; cctx->op += literalLength;
}
void LDM_outputBlock(LDM_CCtx *cctx,
const U32 literalLength,
const U32 offset,
const U32 matchLength) {
BYTE *pToken = cctx->op++;
/* Encode the literal length and literals. */
LDM_encodeLiteralLengthAndLiterals(cctx, pToken, literalLength);
/* Encode the offset. */ /* Encode the offset. */
LDM_write32(cctx->op, offset); MEM_write32(cctx->op, offset);
cctx->op += LDM_OFFSET_SIZE; cctx->op += LDM_OFFSET_SIZE;
/* Encode the match length. */ /* Encode the match length. */
if (matchLength >= ML_MASK) { if (matchLength >= ML_MASK) {
unsigned matchLengthRemaining = matchLength; unsigned matchLengthRemaining = matchLength;
*token += ML_MASK; *pToken += ML_MASK;
matchLengthRemaining -= ML_MASK; matchLengthRemaining -= ML_MASK;
LDM_write32(cctx->op, 0xFFFFFFFF); MEM_write32(cctx->op, 0xFFFFFFFF);
while (matchLengthRemaining >= 4*0xFF) { while (matchLengthRemaining >= 4*0xFF) {
cctx->op += 4; cctx->op += 4;
LDM_write32(cctx->op, 0xffffffff); MEM_write32(cctx->op, 0xffffffff);
matchLengthRemaining -= 4*0xFF; matchLengthRemaining -= 4*0xFF;
} }
cctx->op += matchLengthRemaining / 255; cctx->op += matchLengthRemaining / 255;
*(cctx->op)++ = (BYTE)(matchLengthRemaining % 255); *(cctx->op)++ = (BYTE)(matchLengthRemaining % 255);
} else { } else {
*token += (BYTE)(matchLength); *pToken += (BYTE)(matchLength);
} }
} }
// TODO: srcSize and maxDstSize is unused // TODO: maxDstSize is unused. This function may seg fault when writing
// beyond the size of dst, as it does not check maxDstSize. Writing to
// a buffer and performing checks is a possible solution.
//
// This is based upon lz4.
size_t LDM_compress(const void *src, size_t srcSize, size_t LDM_compress(const void *src, size_t srcSize,
void *dst, size_t maxDstSize) { void *dst, size_t maxDstSize) {
LDM_CCtx cctx; LDM_CCtx cctx;
initializeCCtx(&cctx, src, srcSize, dst, maxDstSize); LDM_initializeCCtx(&cctx, src, srcSize, dst, maxDstSize);
/* Hash the first position and put it into the hash table. */ /* Hash the first position and put it into the hash table. */
LDM_putHashOfCurrentPosition(&cctx); LDM_putHashOfCurrentPosition(&cctx);
@ -506,21 +479,27 @@ size_t LDM_compress(const void *src, size_t srcSize,
* length) and update pointers and hashes. * length) and update pointers and hashes.
*/ */
{ {
unsigned const literalLength = (unsigned)(cctx.ip - cctx.anchor); const U32 literalLength = cctx.ip - cctx.anchor;
unsigned const offset = cctx.ip - match; const U32 offset = cctx.ip - match;
unsigned const matchLength = countMatchLength( const U32 matchLength = LDM_countMatchLength(
cctx.ip + MINMATCH, match + MINMATCH, cctx.ihashLimit); cctx.ip + LDM_MIN_MATCH_LENGTH, match + LDM_MIN_MATCH_LENGTH,
cctx.ihashLimit);
#ifdef COMPUTE_STATS #ifdef COMPUTE_STATS
cctx.stats.totalLiteralLength += literalLength; cctx.stats.totalLiteralLength += literalLength;
cctx.stats.totalOffset += offset; cctx.stats.totalOffset += offset;
cctx.stats.totalMatchLength += matchLength + MINMATCH; cctx.stats.totalMatchLength += matchLength + LDM_MIN_MATCH_LENGTH;
cctx.stats.minOffset =
offset < cctx.stats.minOffset ? offset : cctx.stats.minOffset;
cctx.stats.maxOffset =
offset > cctx.stats.maxOffset ? offset : cctx.stats.maxOffset;
#endif #endif
outputBlock(&cctx, literalLength, offset, matchLength); LDM_outputBlock(&cctx, literalLength, offset, matchLength);
// Move ip to end of block, inserting hashes at each position. // Move ip to end of block, inserting hashes at each position.
cctx.nextIp = cctx.ip + cctx.step; cctx.nextIp = cctx.ip + cctx.step;
while (cctx.ip < cctx.anchor + MINMATCH + matchLength + literalLength) { while (cctx.ip < cctx.anchor + LDM_MIN_MATCH_LENGTH +
matchLength + literalLength) {
if (cctx.ip > cctx.lastPosHashed) { if (cctx.ip > cctx.lastPosHashed) {
// TODO: Simplify. // TODO: Simplify.
LDM_updateLastHashFromNextHash(&cctx); LDM_updateLastHashFromNextHash(&cctx);
@ -538,31 +517,22 @@ size_t LDM_compress(const void *src, size_t srcSize,
_last_literals: _last_literals:
/* Encode the last literals (no more matches). */ /* Encode the last literals (no more matches). */
{ {
size_t const lastRun = (size_t)(cctx.iend - cctx.anchor); const size_t lastRun = (size_t)(cctx.iend - cctx.anchor);
if (lastRun >= RUN_MASK) { BYTE *pToken = cctx.op++;
size_t accumulator = lastRun - RUN_MASK; LDM_encodeLiteralLengthAndLiterals(&cctx, pToken, lastRun);
*(cctx.op)++ = RUN_MASK << ML_BITS;
for(; accumulator >= 255; accumulator -= 255) {
*(cctx.op)++ = 255;
}
*(cctx.op)++ = (BYTE)accumulator;
} else {
*(cctx.op)++ = (BYTE)(lastRun << ML_BITS);
}
memcpy(cctx.op, cctx.anchor, lastRun);
cctx.op += lastRun;
} }
#ifdef COMPUTE_STATS #ifdef COMPUTE_STATS
printCompressStats(&cctx); LDM_printCompressStats(&cctx.stats);
LDM_outputHashtableOccupancy(cctx.hashTable, LDM_HASHTABLESIZE_U32);
#endif #endif
return (cctx.op - (const BYTE *)cctx.obase); return (cctx.op - (const BYTE *)cctx.obase);
} }
typedef struct LDM_DCtx { struct LDM_DCtx {
size_t compressSize; size_t compressedSize;
size_t maxDecompressSize; size_t maxDecompressedSize;
const BYTE *ibase; /* Base of input */ const BYTE *ibase; /* Base of input */
const BYTE *ip; /* Current input position */ const BYTE *ip; /* Current input position */
@ -571,26 +541,25 @@ typedef struct LDM_DCtx {
const BYTE *obase; /* Base of output */ const BYTE *obase; /* Base of output */
BYTE *op; /* Current output position */ BYTE *op; /* Current output position */
const BYTE *oend; /* End of output */ const BYTE *oend; /* End of output */
} LDM_DCtx; };
static void LDM_initializeDCtx(LDM_DCtx *dctx, void LDM_initializeDCtx(LDM_DCtx *dctx,
const void *src, size_t compressSize, const void *src, size_t compressedSize,
void *dst, size_t maxDecompressSize) { void *dst, size_t maxDecompressedSize) {
dctx->compressSize = compressSize; dctx->compressedSize = compressedSize;
dctx->maxDecompressSize = maxDecompressSize; dctx->maxDecompressedSize = maxDecompressedSize;
dctx->ibase = src; dctx->ibase = src;
dctx->ip = (const BYTE *)src; dctx->ip = (const BYTE *)src;
dctx->iend = dctx->ip + dctx->compressSize; dctx->iend = dctx->ip + dctx->compressedSize;
dctx->op = dst; dctx->op = dst;
dctx->oend = dctx->op + dctx->maxDecompressSize; dctx->oend = dctx->op + dctx->maxDecompressedSize;
} }
size_t LDM_decompress(const void *src, size_t compressSize, size_t LDM_decompress(const void *src, size_t compressedSize,
void *dst, size_t maxDecompressSize) { void *dst, size_t maxDecompressedSize) {
LDM_DCtx dctx; LDM_DCtx dctx;
LDM_initializeDCtx(&dctx, src, compressSize, dst, maxDecompressSize); LDM_initializeDCtx(&dctx, src, compressedSize, dst, maxDecompressedSize);
while (dctx.ip < dctx.iend) { while (dctx.ip < dctx.iend) {
BYTE *cpy; BYTE *cpy;
@ -598,7 +567,7 @@ size_t LDM_decompress(const void *src, size_t compressSize,
size_t length, offset; size_t length, offset;
/* Get the literal length. */ /* Get the literal length. */
unsigned const token = *(dctx.ip)++; const unsigned token = *(dctx.ip)++;
if ((length = (token >> ML_BITS)) == RUN_MASK) { if ((length = (token >> ML_BITS)) == RUN_MASK) {
unsigned s; unsigned s;
do { do {
@ -614,7 +583,7 @@ size_t LDM_decompress(const void *src, size_t compressSize,
dctx.op = cpy; dctx.op = cpy;
//TODO : dynamic offset size //TODO : dynamic offset size
offset = LDM_read32(dctx.ip); offset = MEM_read32(dctx.ip);
dctx.ip += LDM_OFFSET_SIZE; dctx.ip += LDM_OFFSET_SIZE;
match = dctx.op - offset; match = dctx.op - offset;
@ -627,7 +596,7 @@ size_t LDM_decompress(const void *src, size_t compressSize,
length += s; length += s;
} while (s == 255); } while (s == 255);
} }
length += MINMATCH; length += LDM_MIN_MATCH_LENGTH;
/* Copy match. */ /* Copy match. */
cpy = dctx.op + length; cpy = dctx.op + length;
@ -640,6 +609,11 @@ size_t LDM_decompress(const void *src, size_t compressSize,
return dctx.op - (BYTE *)dst; return dctx.op - (BYTE *)dst;
} }
// TODO: implement and test hash function
void LDM_test(void) {
}
/* /*
void LDM_test(const void *src, size_t srcSize, void LDM_test(const void *src, size_t srcSize,
void *dst, size_t maxDstSize) { void *dst, size_t maxDstSize) {

135
contrib/long_distance_matching/versions/v0.5/ldm.h
View File

@ -3,24 +3,141 @@
#include <stddef.h> /* size_t */ #include <stddef.h> /* size_t */
#define LDM_COMPRESS_SIZE 4 #include "mem.h" // from /lib/common/mem.h
#define LDM_DECOMPRESS_SIZE 4
#define LDM_HEADER_SIZE ((LDM_COMPRESS_SIZE)+(LDM_DECOMPRESS_SIZE))
#define LDM_COMPRESS_SIZE 8
#define LDM_DECOMPRESS_SIZE 8
#define LDM_HEADER_SIZE ((LDM_COMPRESS_SIZE)+(LDM_DECOMPRESS_SIZE))
#define LDM_OFFSET_SIZE 4
// Defines the size of the hash table.
#define LDM_MEMORY_USAGE 22
#define LDM_HASHLOG (LDM_MEMORY_USAGE-2)
#define LDM_HASHTABLESIZE (1 << (LDM_MEMORY_USAGE))
#define LDM_HASHTABLESIZE_U32 ((LDM_HASHTABLESIZE) >> 2)
#define WINDOW_SIZE (1 << 25)
//These should be multiples of four.
#define LDM_MIN_MATCH_LENGTH 8
#define LDM_HASH_LENGTH 8
typedef U32 offset_t;
typedef U32 hash_t;
typedef struct LDM_hashEntry LDM_hashEntry;
typedef struct LDM_compressStats LDM_compressStats;
typedef struct LDM_CCtx LDM_CCtx;
typedef struct LDM_DCtx LDM_DCtx;
/**
* Compresses src into dst.
*
* NB: This currently ignores maxDstSize and assumes enough space is available.
*
* Block format (see lz4 documentation for more information):
* github.com/lz4/lz4/blob/dev/doc/lz4_Block_format.md
*
* A block is composed of sequences. Each sequence begins with a token, which
* is a one-byte value separated into two 4-bit fields.
*
* The first field uses the four high bits of the token and encodes the literal
* length. If the field value is 0, there is no literal. If it is 15,
* additional bytes are added (each ranging from 0 to 255) to the previous
* value to produce a total length.
*
* Following the token and optional length bytes are the literals.
*
* Next are the 4 bytes representing the offset of the match (2 in lz4),
* representing the position to copy the literals.
*
* The lower four bits of the token encode the match length. With additional
* bytes added similarly to the additional literal length bytes after the offset.
*
* The last sequence is incomplete and stops right after the lieterals.
*
*/
size_t LDM_compress(const void *src, size_t srcSize, size_t LDM_compress(const void *src, size_t srcSize,
void *dst, size_t maxDstSize); void *dst, size_t maxDstSize);
/**
* Initialize the compression context.
*/
void LDM_initializeCCtx(LDM_CCtx *cctx,
const void *src, size_t srcSize,
void *dst, size_t maxDstSize);
/**
* Prints the percentage of the hash table occupied (where occupied is defined
* as the entry being non-zero).
*/
void LDM_outputHashtableOccupancy(const LDM_hashEntry *hashTable,
U32 hashTableSize);
/**
* Outputs compression statistics to stdout.
*/
void LDM_printCompressStats(const LDM_compressStats *stats);
/**
* Checks whether the LDM_MIN_MATCH_LENGTH bytes from p are the same as the
* LDM_MIN_MATCH_LENGTH bytes from match.
*
* This assumes LDM_MIN_MATCH_LENGTH is a multiple of four.
*
* Return 1 if valid, 0 otherwise.
*/
int LDM_isValidMatch(const BYTE *pIn, const BYTE *pMatch);
/**
* Counts the number of bytes that match from pIn and pMatch,
* up to pInLimit.
*/
U32 LDM_countMatchLength(const BYTE *pIn, const BYTE *pMatch,
const BYTE *pInLimit);
/**
* Encode the literal length followed by the literals.
*
* The literal length is written to the upper four bits of pToken, with
* additional bytes written to the output as needed (see lz4).
*
* This is followed by literalLength bytes corresponding to the literals.
*/
void LDM_encodeLiteralLengthAndLiterals(
LDM_CCtx *cctx, BYTE *pToken, const U32 literalLength);
/**
* Write current block (literals, literal length, match offset,
* match length).
*/
void LDM_outputBlock(LDM_CCtx *cctx,
const U32 literalLength,
const U32 offset,
const U32 matchLength);
/**
* Decompresses src into dst.
*
* Note: assumes src does not have a header.
*/
size_t LDM_decompress(const void *src, size_t srcSize, size_t LDM_decompress(const void *src, size_t srcSize,
void *dst, size_t maxDstSize); void *dst, size_t maxDstSize);
/** /**
* Reads the header from src and writes the compressed size and * Initialize the decompression context.
* decompressed size into compressSize and decompressSize respectively.
*/ */
void LDM_readHeader(const void *src, size_t *compressSize, void LDM_initializeDCtx(LDM_DCtx *dctx,
size_t *decompressSize); const void *src, size_t compressedSize,
void *dst, size_t maxDecompressedSize);
void LDM_test(const void *src, size_t srcSize, /**
void *dst, size_t maxDstSize); * Reads the header from src and writes the compressed size and
* decompressed size into compressedSize and decompressedSize respectively.
*
* NB: LDM_compress and LDM_decompress currently do not add/read headers.
*/
void LDM_readHeader(const void *src, U64 *compressedSize,
U64 *decompressedSize);
void LDM_test(void);
#endif /* LDM_H */ #endif /* LDM_H */

254
contrib/long_distance_matching/versions/v0.5/main-ldm.c
View File

@ -1,5 +1,3 @@
// TODO: file size must fit into a U32
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
@ -12,18 +10,23 @@
#include <fcntl.h> #include <fcntl.h>
#include "ldm.h" #include "ldm.h"
#include "zstd.h"
#define DEBUG #define DEBUG
//#define TEST //#define TEST
/* Compress file given by fname and output to oname. /* Compress file given by fname and output to oname.
* Returns 0 if successful, error code otherwise. * Returns 0 if successful, error code otherwise.
*
* TODO: This currently seg faults if the compressed size is > the decompress
* size due to the mmapping and output file size allocated to be the input size.
* The compress function should check before writing or buffer writes.
*/ */
static int compress(const char *fname, const char *oname) { static int compress(const char *fname, const char *oname) {
int fdin, fdout; int fdin, fdout;
struct stat statbuf; struct stat statbuf;
char *src, *dst; char *src, *dst;
size_t maxCompressSize, compressSize; size_t maxCompressedSize, compressedSize;
/* Open the input file. */ /* Open the input file. */
if ((fdin = open(fname, O_RDONLY)) < 0) { if ((fdin = open(fname, O_RDONLY)) < 0) {
@ -43,11 +46,11 @@ static int compress(const char *fname, const char *oname) {
return 1; return 1;
} }
maxCompressSize = statbuf.st_size + LDM_HEADER_SIZE; maxCompressedSize = statbuf.st_size + LDM_HEADER_SIZE;
/* Go to the location corresponding to the last byte. */ /* Go to the location corresponding to the last byte. */
/* TODO: fallocate? */ /* TODO: fallocate? */
if (lseek(fdout, maxCompressSize - 1, SEEK_SET) == -1) { if (lseek(fdout, maxCompressedSize - 1, SEEK_SET) == -1) {
perror("lseek error"); perror("lseek error");
return 1; return 1;
} }
@ -66,39 +69,32 @@ static int compress(const char *fname, const char *oname) {
} }
/* mmap the output file */ /* mmap the output file */
if ((dst = mmap(0, maxCompressSize, PROT_READ | PROT_WRITE, if ((dst = mmap(0, maxCompressedSize, PROT_READ | PROT_WRITE,
MAP_SHARED, fdout, 0)) == (caddr_t) - 1) { MAP_SHARED, fdout, 0)) == (caddr_t) - 1) {
perror("mmap error for output"); perror("mmap error for output");
return 1; return 1;
} }
/* compressedSize = LDM_HEADER_SIZE +
#ifdef TEST
LDM_test(src, statbuf.st_size,
dst + LDM_HEADER_SIZE, statbuf.st_size);
#endif
*/
compressSize = LDM_HEADER_SIZE +
LDM_compress(src, statbuf.st_size, LDM_compress(src, statbuf.st_size,
dst + LDM_HEADER_SIZE, statbuf.st_size); dst + LDM_HEADER_SIZE, maxCompressedSize);
// Write compress and decompress size to header // Write compress and decompress size to header
// TODO: should depend on LDM_DECOMPRESS_SIZE write32 // TODO: should depend on LDM_DECOMPRESS_SIZE write32
memcpy(dst, &compressSize, 4); memcpy(dst, &compressedSize, 8);
memcpy(dst + 4, &(statbuf.st_size), 4); memcpy(dst + 8, &(statbuf.st_size), 8);
#ifdef DEBUG #ifdef DEBUG
printf("Compressed size: %zu\n", compressSize); printf("Compressed size: %zu\n", compressedSize);
printf("Decompressed size: %zu\n", (size_t)statbuf.st_size); printf("Decompressed size: %zu\n", (size_t)statbuf.st_size);
#endif #endif
// Truncate file to compressSize. // Truncate file to compressedSize.
ftruncate(fdout, compressSize); ftruncate(fdout, compressedSize);
printf("%25s : %6u -> %7u - %s (%.1f%%)\n", fname, printf("%25s : %6u -> %7u - %s (%.1f%%)\n", fname,
(unsigned)statbuf.st_size, (unsigned)compressSize, oname, (unsigned)statbuf.st_size, (unsigned)compressedSize, oname,
(double)compressSize / (statbuf.st_size) * 100); (double)compressedSize / (statbuf.st_size) * 100);
// Close files. // Close files.
close(fdin); close(fdin);
@ -114,7 +110,8 @@ static int decompress(const char *fname, const char *oname) {
int fdin, fdout; int fdin, fdout;
struct stat statbuf; struct stat statbuf;
char *src, *dst; char *src, *dst;
size_t compressSize, decompressSize, outSize; U64 compressedSize, decompressedSize;
size_t outSize;
/* Open the input file. */ /* Open the input file. */
if ((fdin = open(fname, O_RDONLY)) < 0) { if ((fdin = open(fname, O_RDONLY)) < 0) {
@ -142,10 +139,10 @@ static int decompress(const char *fname, const char *oname) {
} }
/* Read the header. */ /* Read the header. */
LDM_readHeader(src, &compressSize, &decompressSize); LDM_readHeader(src, &compressedSize, &decompressedSize);
/* Go to the location corresponding to the last byte. */ /* Go to the location corresponding to the last byte. */
if (lseek(fdout, decompressSize - 1, SEEK_SET) == -1) { if (lseek(fdout, decompressedSize - 1, SEEK_SET) == -1) {
perror("lseek error"); perror("lseek error");
return 1; return 1;
} }
@ -157,7 +154,7 @@ static int decompress(const char *fname, const char *oname) {
} }
/* mmap the output file */ /* mmap the output file */
if ((dst = mmap(0, decompressSize, PROT_READ | PROT_WRITE, if ((dst = mmap(0, decompressedSize, PROT_READ | PROT_WRITE,
MAP_SHARED, fdout, 0)) == (caddr_t) - 1) { MAP_SHARED, fdout, 0)) == (caddr_t) - 1) {
perror("mmap error for output"); perror("mmap error for output");
return 1; return 1;
@ -165,7 +162,7 @@ static int decompress(const char *fname, const char *oname) {
outSize = LDM_decompress( outSize = LDM_decompress(
src + LDM_HEADER_SIZE, statbuf.st_size - LDM_HEADER_SIZE, src + LDM_HEADER_SIZE, statbuf.st_size - LDM_HEADER_SIZE,
dst, decompressSize); dst, decompressedSize);
printf("Ret size out: %zu\n", outSize); printf("Ret size out: %zu\n", outSize);
ftruncate(fdout, outSize); ftruncate(fdout, outSize);
@ -265,204 +262,9 @@ int main(int argc, const char *argv[]) {
} }
/* verify */ /* verify */
verify(inpFilename, decFilename); verify(inpFilename, decFilename);
return 0;
}
#ifdef TEST
#if 0 LDM_test();
static size_t compress_file(FILE *in, FILE *out, size_t *size_in,
size_t *size_out) {
char *src, *buf = NULL;
size_t r = 1;
size_t size, n, k, count_in = 0, count_out = 0, offset, frame_size = 0;
src = malloc(BUF_SIZE);
if (!src) {
printf("Not enough memory\n");
goto cleanup;
}
size = BUF_SIZE + LDM_HEADER_SIZE;
buf = malloc(size);
if (!buf) {
printf("Not enough memory\n");
goto cleanup;
}
for (;;) {
k = fread(src, 1, BUF_SIZE, in);
if (k == 0)
break;
count_in += k;
n = LDM_compress(src, buf, k, BUF_SIZE);
// n = k;
// offset += n;
offset = k;
count_out += k;
// k = fwrite(src, 1, offset, out);
k = fwrite(buf, 1, offset, out);
if (k < offset) {
if (ferror(out))
printf("Write failed\n");
else
printf("Short write\n");
goto cleanup;
}
}
*size_in = count_in;
*size_out = count_out;
r = 0;
cleanup:
free(src);
free(buf);
return r;
}
static size_t decompress_file(FILE *in, FILE *out) {
void *src = malloc(BUF_SIZE);
void *dst = NULL;
size_t dst_capacity = BUF_SIZE;
size_t ret = 1;
size_t bytes_written = 0;
if (!src) {
perror("decompress_file(src)");
goto cleanup;
}
while (ret != 0) {
/* Load more input */
size_t src_size = fread(src, 1, BUF_SIZE, in);
void *src_ptr = src;
void *src_end = src_ptr + src_size;
if (src_size == 0 || ferror(in)) {
printf("(TODO): Decompress: not enough input or error reading file\n");
//TODO
ret = 0;
goto cleanup;
}
/* Allocate destination buffer if it hasn't been allocated already */
if (!dst) {
dst = malloc(dst_capacity);
if (!dst) {
perror("decompress_file(dst)");
goto cleanup;
}
}
// TODO
/* Decompress:
* Continue while there is more input to read.
*/
while (src_ptr != src_end && ret != 0) {
// size_t dst_size = src_size;
size_t dst_size = LDM_decompress(src, dst, src_size, dst_capacity);
size_t written = fwrite(dst, 1, dst_size, out);
// printf("Writing %zu bytes\n", dst_size);
bytes_written += dst_size;
if (written != dst_size) {
printf("Decompress: Failed to write to file\n");
goto cleanup;
}
src_ptr += src_size;
src_size = src_end - src_ptr;
}
/* Update input */
}
printf("Wrote %zu bytes\n", bytes_written);
cleanup:
free(src);
free(dst);
return ret;
}
int main2(int argc, char *argv[]) {
char inpFilename[256] = { 0 };
char ldmFilename[256] = { 0 };
char decFilename[256] = { 0 };
if (argc < 2) {
printf("Please specify input filename\n");
return 0;
}
snprintf(inpFilename, 256, "%s", argv[1]);
snprintf(ldmFilename, 256, "%s.ldm", argv[1]);
snprintf(decFilename, 256, "%s.ldm.dec", argv[1]);
printf("inp = [%s]\n", inpFilename);
printf("ldm = [%s]\n", ldmFilename);
printf("dec = [%s]\n", decFilename);
/* compress */
{
FILE *inpFp = fopen(inpFilename, "rb");
FILE *outFp = fopen(ldmFilename, "wb");
size_t sizeIn = 0;
size_t sizeOut = 0;
size_t ret;
printf("compress : %s -> %s\n", inpFilename, ldmFilename);
ret = compress_file(inpFp, outFp, &sizeIn, &sizeOut);
if (ret) {
printf("compress : failed with code %zu\n", ret);
return ret;
}
printf("%s: %zu → %zu bytes, %.1f%%\n",
inpFilename, sizeIn, sizeOut,
(double)sizeOut / sizeIn * 100);
printf("compress : done\n");
fclose(outFp);
fclose(inpFp);
}
/* decompress */
{
FILE *inpFp = fopen(ldmFilename, "rb");
FILE *outFp = fopen(decFilename, "wb");
size_t ret;
printf("decompress : %s -> %s\n", ldmFilename, decFilename);
ret = decompress_file(inpFp, outFp);
if (ret) {
printf("decompress : failed with code %zu\n", ret);
return ret;
}
printf("decompress : done\n");
fclose(outFp);
fclose(inpFp);
}
/* verify */
{
FILE *inpFp = fopen(inpFilename, "rb");
FILE *decFp = fopen(decFilename, "rb");
printf("verify : %s <-> %s\n", inpFilename, decFilename);
const int cmp = compare(inpFp, decFp);
if(0 == cmp) {
printf("verify : OK\n");
} else {
printf("verify : NG\n");
}
fclose(decFp);
fclose(inpFp);
}
return 0;
}
#endif #endif
return 0;
}

69
contrib/long_distance_matching/versions/v0.5/util.c
View File

@ -1,69 +0,0 @@
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <stdio.h>
#include "util.h"
typedef uint8_t BYTE;
typedef uint16_t U16;
typedef uint32_t U32;
typedef int32_t S32;
typedef uint64_t U64;
unsigned LDM_isLittleEndian(void) {
const union { U32 u; BYTE c[4]; } one = { 1 };
return one.c[0];
}
U16 LDM_read16(const void *memPtr) {
U16 val;
memcpy(&val, memPtr, sizeof(val));
return val;
}
U16 LDM_readLE16(const void *memPtr) {
if (LDM_isLittleEndian()) {
return LDM_read16(memPtr);
} else {
const BYTE *p = (const BYTE *)memPtr;
return (U16)((U16)p[0] + (p[1] << 8));
}
}
void LDM_write16(void *memPtr, U16 value){
memcpy(memPtr, &value, sizeof(value));
}
void LDM_write32(void *memPtr, U32 value) {
memcpy(memPtr, &value, sizeof(value));
}
void LDM_writeLE16(void *memPtr, U16 value) {
if (LDM_isLittleEndian()) {
LDM_write16(memPtr, value);
} else {
BYTE* p = (BYTE *)memPtr;
p[0] = (BYTE) value;
p[1] = (BYTE)(value>>8);
}
}
U32 LDM_read32(const void *ptr) {
return *(const U32 *)ptr;
}
U64 LDM_read64(const void *ptr) {
return *(const U64 *)ptr;
}
void LDM_copy8(void *dst, const void *src) {
memcpy(dst, src, 8);
}
BYTE LDM_readByte(const void *memPtr) {
BYTE val;
memcpy(&val, memPtr, 1);
return val;
}

25
contrib/long_distance_matching/versions/v0.5/util.h
View File

@ -1,25 +0,0 @@
#ifndef LDM_UTIL_H
#define LDM_UTIL_H
unsigned LDM_isLittleEndian(void);
uint16_t LDM_read16(const void *memPtr);
uint16_t LDM_readLE16(const void *memPtr);
void LDM_write16(void *memPtr, uint16_t value);
void LDM_write32(void *memPtr, uint32_t value);
void LDM_writeLE16(void *memPtr, uint16_t value);
uint32_t LDM_read32(const void *ptr);
uint64_t LDM_read64(const void *ptr);
void LDM_copy8(void *dst, const void *src);
uint8_t LDM_readByte(const void *ptr);
#endif /* LDM_UTIL_H */