+++ /dev/null
-# This Makefile presumes libzstd is installed, using `sudo make install`
-
-CFLAGS ?= -O3
-DEBUGFLAGS = -Wall -Wextra -Wcast-qual -Wcast-align -Wshadow \
- -Wstrict-aliasing=1 -Wswitch-enum -Wdeclaration-after-statement \
- -Wstrict-prototypes -Wundef -Wpointer-arith -Wformat-security \
- -Wvla -Wformat=2 -Winit-self -Wfloat-equal -Wwrite-strings \
- -Wredundant-decls
-CFLAGS += $(DEBUGFLAGS) $(MOREFLAGS)
-FLAGS = $(CPPFLAGS) $(CFLAGS)
-
-LDFLAGS += -lzstd
-
-.PHONY: default all clean
-
-default: all
-
-all: main-ldm
-
-#main : ldm.c main.c
-# $(CC) $(CPPFLAGS) $(CFLAGS) $^ $(LDFLAGS) -o $@
-
-main-ldm : util.c ldm.c main-ldm.c
- $(CC) $(CPPFLAGS) $(CFLAGS) $^ $(LDFLAGS) -o $@
-
-clean:
- @rm -f core *.o tmp* result* *.ldm *.ldm.dec \
- main main-ldm
- @echo Cleaning completed
-
+++ /dev/null
-This version uses simple lz4-style compression:
-- A 4-byte hash is inserted into the hash table for every position.
-- Hash table replacement policy: direct overwrite.
+++ /dev/null
-#include <stdlib.h>
-#include <string.h>
-#include <stdint.h>
-#include <stdio.h>
-
-
-#include "ldm.h"
-#include "util.h"
-
-#define HASH_EVERY 1
-
-#define LDM_MEMORY_USAGE 16
-#define LDM_HASHLOG (LDM_MEMORY_USAGE-2)
-#define LDM_HASHTABLESIZE (1 << (LDM_MEMORY_USAGE))
-#define LDM_HASHTABLESIZE_U32 ((LDM_HASHTABLESIZE) >> 2)
-#define LDM_HASH_SIZE_U32 (1 << (LDM_HASHLOG))
-
-#define LDM_OFFSET_SIZE 4
-
-#define WINDOW_SIZE (1 << 20)
-#define MAX_WINDOW_SIZE 31
-#define HASH_SIZE 4
-#define LDM_HASH_LENGTH 4
-#define MINMATCH 4
-
-#define ML_BITS 4
-#define ML_MASK ((1U<<ML_BITS)-1)
-#define RUN_BITS (8-ML_BITS)
-#define RUN_MASK ((1U<<RUN_BITS)-1)
-
-//#define LDM_ROLLING_HASH
-//#define LDM_DEBUG
-
-typedef uint8_t BYTE;
-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 LDM_hashEntry {
- offset_t offset;
-} LDM_hashEntry;
-
-typedef struct LDM_compressStats {
- U32 numMatches;
- U32 totalMatchLength;
- U32 totalLiteralLength;
- U64 totalOffset;
-} LDM_compressStats;
-
-static void LDM_printCompressStats(const LDM_compressStats *stats) {
- 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("=====================\n");
-}
-
-typedef struct LDM_CCtx {
- size_t isize; /* Input size */
- size_t maxOSize; /* Maximum output size */
-
- const BYTE *ibase; /* Base of input */
- const BYTE *ip; /* Current input position */
- const BYTE *iend; /* End of input */
-
- // Maximum input position such that hashing at the position does not exceed
- // end of input.
- const BYTE *ihashLimit;
-
- // Maximum input position such that finding a match of at least the minimum
- // match length does not exceed end of input.
- const BYTE *imatchLimit;
-
- const BYTE *obase; /* Base of output */
- BYTE *op; /* Output */
-
- const BYTE *anchor; /* Anchor to start of current (match) block */
-
- LDM_compressStats stats; /* Compression statistics */
-
- LDM_hashEntry hashTable[LDM_HASHTABLESIZE_U32];
-
- const BYTE *lastPosHashed; /* Last position hashed */
- hash_t lastHash; /* Hash corresponding to lastPosHashed */
- const BYTE *nextIp;
- hash_t nextHash; /* Hash corresponding to nextIp */
-
- unsigned step;
-} LDM_CCtx;
-
-#ifdef LDM_ROLLING_HASH
-/**
- * Convert a sum computed from LDM_getRollingHash to a hash value in the range
- * of the hash table.
- */
-static hash_t LDM_sumToHash(U32 sum) {
- return sum % (LDM_HASHTABLESIZE >> 2);
-// return sum & (LDM_HASHTABLESIZE - 1);
-}
-
-static U32 LDM_getRollingHash(const char *data, U32 len) {
- U32 i;
- U32 s1, s2;
- const schar *buf = (const schar *)data;
-
- s1 = s2 = 0;
- for (i = 0; i < (len - 4); i += 4) {
- s2 += (4 * (s1 + buf[i])) + (3 * buf[i + 1]) +
- (2 * buf[i + 2]) + (buf[i + 3]);
- s1 += buf[i] + buf[i + 1] + buf[i + 2] + buf[i + 3];
- }
- for(; i < len; i++) {
- s1 += buf[i];
- s2 += s1;
- }
- return (s1 & 0xffff) + (s2 << 16);
-}
-
-static hash_t LDM_hashPosition(const void * const p) {
- return LDM_sumToHash(LDM_getRollingHash((const char *)p, LDM_HASH_LENGTH));
-}
-
-typedef struct LDM_sumStruct {
- U16 s1, s2;
-} LDM_sumStruct;
-
-static void LDM_getRollingHashParts(U32 sum, LDM_sumStruct *sumStruct) {
- sumStruct->s1 = sum & 0xffff;
- sumStruct->s2 = sum >> 16;
-}
-
-#else
-static hash_t LDM_hash(U32 sequence) {
- return ((sequence * 2654435761U) >> ((32)-LDM_HASHLOG));
-}
-
-static hash_t LDM_hashPosition(const void * const p) {
- return LDM_hash(LDM_read32(p));
-}
-#endif
-
-/*
-static hash_t LDM_hash5(U64 sequence) {
- static const U64 prime5bytes = 889523592379ULL;
- static const U64 prime8bytes = 11400714785074694791ULL;
- const U32 hashLog = LDM_HASHLOG;
- if (LDM_isLittleEndian())
- return (((sequence << 24) * prime5bytes) >> (64 - hashLog));
- else
- return (((sequence >> 24) * prime8bytes) >> (64 - hashLog));
-}
-*/
-
-static void LDM_putHashOfCurrentPositionFromHash(
- LDM_CCtx *cctx, hash_t hash) {
- if (((cctx->ip - cctx->ibase) & HASH_EVERY) != HASH_EVERY) {
- return;
- }
- (cctx->hashTable)[hash] = (LDM_hashEntry){ (hash_t)(cctx->ip - cctx->ibase) };
- cctx->lastPosHashed = cctx->ip;
- cctx->lastHash = hash;
-}
-
-static void LDM_putHashOfCurrentPosition(LDM_CCtx *cctx) {
- hash_t hash = LDM_hashPosition(cctx->ip);
- LDM_putHashOfCurrentPositionFromHash(cctx, hash);
-}
-
-static const BYTE *LDM_get_position_on_hash(
- hash_t h, void *tableBase, const BYTE *srcBase) {
- const LDM_hashEntry * const hashTable = (LDM_hashEntry *)tableBase;
- return hashTable[h].offset + srcBase;
-}
-
-static BYTE LDM_read_byte(const void *memPtr) {
- BYTE val;
- memcpy(&val, memPtr, 1);
- return val;
-}
-
-static unsigned LDM_count(const BYTE *pIn, const BYTE *pMatch,
- const BYTE *pInLimit) {
- const BYTE * const pStart = pIn;
- while (pIn < pInLimit - 1) {
- BYTE const diff = LDM_read_byte(pMatch) ^ LDM_read_byte(pIn);
- if (!diff) {
- pIn++;
- pMatch++;
- continue;
- }
- return (unsigned)(pIn - pStart);
- }
- return (unsigned)(pIn - pStart);
-}
-
-void LDM_readHeader(const void *src, size_t *compressSize,
- size_t *decompressSize) {
- const U32 *ip = (const U32 *)src;
- *compressSize = *ip++;
- *decompressSize = *ip;
-}
-
-static void LDM_initializeCCtx(LDM_CCtx *cctx,
- const void *src, size_t srcSize,
- void *dst, size_t maxDstSize) {
- cctx->isize = srcSize;
- cctx->maxOSize = maxDstSize;
-
- cctx->ibase = (const BYTE *)src;
- cctx->ip = cctx->ibase;
- cctx->iend = cctx->ibase + srcSize;
-
- cctx->ihashLimit = cctx->iend - HASH_SIZE;
- cctx->imatchLimit = cctx->iend - MINMATCH;
-
- cctx->obase = (BYTE *)dst;
- cctx->op = (BYTE *)dst;
-
- cctx->anchor = cctx->ibase;
-
- memset(&(cctx->stats), 0, sizeof(cctx->stats));
- memset(cctx->hashTable, 0, sizeof(cctx->hashTable));
-
- cctx->lastPosHashed = NULL;
- cctx->nextIp = NULL;
-
- cctx->step = 1;
-}
-
-static int LDM_findBestMatch(LDM_CCtx *cctx, const BYTE **match) {
- cctx->nextIp = cctx->ip;
-
- do {
- hash_t const h = cctx->nextHash;
- cctx->ip = cctx->nextIp;
- cctx->nextIp += cctx->step;
-
- if (cctx->nextIp > cctx->imatchLimit) {
- return 1;
- }
-
- *match = LDM_get_position_on_hash(h, cctx->hashTable, cctx->ibase);
-
- cctx->nextHash = LDM_hashPosition(cctx->nextIp);
- LDM_putHashOfCurrentPositionFromHash(cctx, h);
- } while (cctx->ip - *match > WINDOW_SIZE ||
- LDM_read64(*match) != LDM_read64(cctx->ip));
- return 0;
-}
-
-// TODO: srcSize and maxDstSize is unused
-size_t LDM_compress(const void *src, size_t srcSize,
- void *dst, size_t maxDstSize) {
- LDM_CCtx cctx;
- LDM_initializeCCtx(&cctx, src, srcSize, dst, maxDstSize);
-
- /* Hash the first position and put it into the hash table. */
- LDM_putHashOfCurrentPosition(&cctx);
- cctx.ip++;
- cctx.nextHash = LDM_hashPosition(cctx.ip);
-
- // TODO: loop condition is not accurate.
- while (1) {
- const BYTE *match;
-
- /**
- * Find a match.
- * If no more matches can be found (i.e. the length of the remaining input
- * is less than the minimum match length), then stop searching for matches
- * and encode the final literals.
- */
- if (LDM_findBestMatch(&cctx, &match) != 0) {
- goto _last_literals;
- }
-
- cctx.stats.numMatches++;
-
- /**
- * Catch up: look back to extend the match backwards from the found match.
- */
- while (cctx.ip > cctx.anchor && match > cctx.ibase &&
- cctx.ip[-1] == match[-1]) {
- cctx.ip--;
- match--;
- }
-
- /**
- * Write current block (literals, literal length, match offset, match
- * length) and update pointers and hashes.
- */
- {
- unsigned const literalLength = (unsigned)(cctx.ip - cctx.anchor);
- unsigned const offset = cctx.ip - match;
- unsigned const matchLength = LDM_count(
- cctx.ip + MINMATCH, match + MINMATCH, cctx.ihashLimit);
- BYTE *token = cctx.op++;
-
- cctx.stats.totalLiteralLength += literalLength;
- cctx.stats.totalOffset += offset;
- cctx.stats.totalMatchLength += matchLength + MINMATCH;
-
- /* Encode the literal length. */
- if (literalLength >= RUN_MASK) {
- int len = (int)literalLength - RUN_MASK;
- *token = (RUN_MASK << ML_BITS);
- for (; len >= 255; len -= 255) {
- *(cctx.op)++ = 255;
- }
- *(cctx.op)++ = (BYTE)len;
- } else {
- *token = (BYTE)(literalLength << ML_BITS);
- }
-
- /* Encode the literals. */
- memcpy(cctx.op, cctx.anchor, literalLength);
- cctx.op += literalLength;
-
- /* Encode the offset. */
- LDM_write32(cctx.op, offset);
- cctx.op += LDM_OFFSET_SIZE;
-
- /* Encode match length */
- if (matchLength >= ML_MASK) {
- unsigned matchLengthRemaining = matchLength;
- *token += ML_MASK;
- matchLengthRemaining -= ML_MASK;
- LDM_write32(cctx.op, 0xFFFFFFFF);
- while (matchLengthRemaining >= 4*0xFF) {
- cctx.op += 4;
- LDM_write32(cctx.op, 0xffffffff);
- matchLengthRemaining -= 4*0xFF;
- }
- cctx.op += matchLengthRemaining / 255;
- *(cctx.op)++ = (BYTE)(matchLengthRemaining % 255);
- } else {
- *token += (BYTE)(matchLength);
- }
-
- /* Update input pointer, inserting hashes into hash table along the
- * way.
- */
- while (cctx.ip < cctx.anchor + MINMATCH + matchLength + literalLength) {
- LDM_putHashOfCurrentPosition(&cctx);
- cctx.ip++;
- }
- }
-
- // Set start of next block to current input pointer.
- cctx.anchor = cctx.ip;
- LDM_putHashOfCurrentPosition(&cctx);
- cctx.nextHash = LDM_hashPosition(++cctx.ip);
- }
-_last_literals:
- /* Encode the last literals (no more matches). */
- {
- size_t const lastRun = (size_t)(cctx.iend - cctx.anchor);
- if (lastRun >= RUN_MASK) {
- size_t accumulator = lastRun - RUN_MASK;
- *(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;
- }
- LDM_printCompressStats(&cctx.stats);
- return (cctx.op - (const BYTE *)cctx.obase);
-}
-
-typedef struct LDM_DCtx {
- size_t compressSize;
- size_t maxDecompressSize;
-
- const BYTE *ibase; /* Base of input */
- const BYTE *ip; /* Current input position */
- const BYTE *iend; /* End of source */
-
- const BYTE *obase; /* Base of output */
- BYTE *op; /* Current output position */
- const BYTE *oend; /* End of output */
-} LDM_DCtx;
-
-static void LDM_initializeDCtx(LDM_DCtx *dctx,
- const void *src, size_t compressSize,
- void *dst, size_t maxDecompressSize) {
- dctx->compressSize = compressSize;
- dctx->maxDecompressSize = maxDecompressSize;
-
- dctx->ibase = src;
- dctx->ip = (const BYTE *)src;
- dctx->iend = dctx->ip + dctx->compressSize;
- dctx->op = dst;
- dctx->oend = dctx->op + dctx->maxDecompressSize;
-
-}
-
-size_t LDM_decompress(const void *src, size_t compressSize,
- void *dst, size_t maxDecompressSize) {
- LDM_DCtx dctx;
- LDM_initializeDCtx(&dctx, src, compressSize, dst, maxDecompressSize);
-
- while (dctx.ip < dctx.iend) {
- BYTE *cpy;
- const BYTE *match;
- size_t length, offset;
-
- /* Get the literal length. */
- unsigned const token = *(dctx.ip)++;
- if ((length = (token >> ML_BITS)) == RUN_MASK) {
- unsigned s;
- do {
- s = *(dctx.ip)++;
- length += s;
- } while (s == 255);
- }
-
- /* Copy literals. */
- cpy = dctx.op + length;
- memcpy(dctx.op, dctx.ip, length);
- dctx.ip += length;
- dctx.op = cpy;
-
- //TODO : dynamic offset size
- offset = LDM_read32(dctx.ip);
- dctx.ip += LDM_OFFSET_SIZE;
- match = dctx.op - offset;
-
- /* Get the match length. */
- length = token & ML_MASK;
- if (length == ML_MASK) {
- unsigned s;
- do {
- s = *(dctx.ip)++;
- length += s;
- } while (s == 255);
- }
- length += MINMATCH;
-
- /* Copy match. */
- cpy = dctx.op + length;
-
- // Inefficient for now
- while (match < cpy - offset && dctx.op < dctx.oend) {
- *(dctx.op)++ = *match++;
- }
- }
- return dctx.op - (BYTE *)dst;
-}
-
-
+++ /dev/null
-#ifndef LDM_H
-#define LDM_H
-
-#include <stddef.h> /* size_t */
-
-#define LDM_COMPRESS_SIZE 4
-#define LDM_DECOMPRESS_SIZE 4
-#define LDM_HEADER_SIZE ((LDM_COMPRESS_SIZE)+(LDM_DECOMPRESS_SIZE))
-
-size_t LDM_compress(const void *src, size_t srcSize,
- void *dst, size_t maxDstSize);
-
-size_t LDM_decompress(const void *src, size_t srcSize,
- void *dst, size_t maxDstSize);
-
-void LDM_readHeader(const void *src, size_t *compressSize,
- size_t *decompressSize);
-
-#endif /* LDM_H */
+++ /dev/null
-// TODO: file size must fit into a U32
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <sys/time.h>
-#include <sys/types.h>
-#include <sys/mman.h>
-#include <sys/stat.h>
-#include <unistd.h>
-#include <zstd.h>
-
-#include <fcntl.h>
-#include "ldm.h"
-
-// #define BUF_SIZE 16*1024 // Block size
-#define DEBUG
-
-//#define ZSTD
-
-/* Compress file given by fname and output to oname.
- * Returns 0 if successful, error code otherwise.
- */
-static int compress(const char *fname, const char *oname) {
- int fdin, fdout;
- struct stat statbuf;
- char *src, *dst;
- size_t maxCompressSize, compressSize;
-
- /* Open the input file. */
- if ((fdin = open(fname, O_RDONLY)) < 0) {
- perror("Error in file opening");
- return 1;
- }
-
- /* Open the output file. */
- if ((fdout = open(oname, O_RDWR | O_CREAT | O_TRUNC, (mode_t)0600)) < 0) {
- perror("Can't create output file");
- return 1;
- }
-
- /* Find the size of the input file. */
- if (fstat (fdin, &statbuf) < 0) {
- perror("Fstat error");
- return 1;
- }
-
- maxCompressSize = statbuf.st_size + LDM_HEADER_SIZE;
-
- /* Go to the location corresponding to the last byte. */
- /* TODO: fallocate? */
- if (lseek(fdout, maxCompressSize - 1, SEEK_SET) == -1) {
- perror("lseek error");
- return 1;
- }
-
- /* Write a dummy byte at the last location. */
- if (write(fdout, "", 1) != 1) {
- perror("write error");
- return 1;
- }
-
- /* mmap the input file. */
- if ((src = mmap(0, statbuf.st_size, PROT_READ, MAP_SHARED, fdin, 0))
- == (caddr_t) - 1) {
- perror("mmap error for input");
- return 1;
- }
-
- /* mmap the output file */
- if ((dst = mmap(0, maxCompressSize, PROT_READ | PROT_WRITE,
- MAP_SHARED, fdout, 0)) == (caddr_t) - 1) {
- perror("mmap error for output");
- return 1;
- }
-
-#ifdef ZSTD
- compressSize = ZSTD_compress(dst, statbuf.st_size,
- src, statbuf.st_size, 1);
-#else
- compressSize = LDM_HEADER_SIZE +
- LDM_compress(src, statbuf.st_size,
- dst + LDM_HEADER_SIZE, statbuf.st_size);
-
- // Write compress and decompress size to header
- // TODO: should depend on LDM_DECOMPRESS_SIZE write32
- memcpy(dst, &compressSize, 4);
- memcpy(dst + 4, &(statbuf.st_size), 4);
-
-#ifdef DEBUG
- printf("Compressed size: %zu\n", compressSize);
- printf("Decompressed size: %zu\n", (size_t)statbuf.st_size);
-#endif
-#endif
-
- // Truncate file to compressSize.
- ftruncate(fdout, compressSize);
-
- printf("%25s : %6u -> %7u - %s (%.1f%%)\n", fname,
- (unsigned)statbuf.st_size, (unsigned)compressSize, oname,
- (double)compressSize / (statbuf.st_size) * 100);
-
- // Close files.
- close(fdin);
- close(fdout);
- return 0;
-}
-
-/* Decompress file compressed using LDM_compress.
- * The input file should have the LDM_HEADER followed by payload.
- * Returns 0 if succesful, and an error code otherwise.
- */
-static int decompress(const char *fname, const char *oname) {
- int fdin, fdout;
- struct stat statbuf;
- char *src, *dst;
- size_t compressSize, decompressSize, outSize;
-
- /* Open the input file. */
- if ((fdin = open(fname, O_RDONLY)) < 0) {
- perror("Error in file opening");
- return 1;
- }
-
- /* Open the output file. */
- if ((fdout = open(oname, O_RDWR | O_CREAT | O_TRUNC, (mode_t)0600)) < 0) {
- perror("Can't create output file");
- return 1;
- }
-
- /* Find the size of the input file. */
- if (fstat (fdin, &statbuf) < 0) {
- perror("Fstat error");
- return 1;
- }
-
- /* mmap the input file. */
- if ((src = mmap(0, statbuf.st_size, PROT_READ, MAP_SHARED, fdin, 0))
- == (caddr_t) - 1) {
- perror("mmap error for input");
- return 1;
- }
-
- /* Read the header. */
- LDM_readHeader(src, &compressSize, &decompressSize);
-
-#ifdef DEBUG
- printf("Size, compressSize, decompressSize: %zu %zu %zu\n",
- (size_t)statbuf.st_size, compressSize, decompressSize);
-#endif
-
- /* Go to the location corresponding to the last byte. */
- if (lseek(fdout, decompressSize - 1, SEEK_SET) == -1) {
- perror("lseek error");
- return 1;
- }
-
- /* write a dummy byte at the last location */
- if (write(fdout, "", 1) != 1) {
- perror("write error");
- return 1;
- }
-
- /* mmap the output file */
- if ((dst = mmap(0, decompressSize, PROT_READ | PROT_WRITE,
- MAP_SHARED, fdout, 0)) == (caddr_t) - 1) {
- perror("mmap error for output");
- return 1;
- }
-
-#ifdef ZSTD
- outSize = ZSTD_decompress(dst, decomrpessed_size,
- src + LDM_HEADER_SIZE,
- statbuf.st_size - LDM_HEADER_SIZE);
-#else
- outSize = LDM_decompress(
- src + LDM_HEADER_SIZE, statbuf.st_size - LDM_HEADER_SIZE,
- dst, decompressSize);
-
- printf("Ret size out: %zu\n", outSize);
- #endif
- ftruncate(fdout, outSize);
-
- close(fdin);
- close(fdout);
- return 0;
-}
-
-/* Compare two files.
- * Returns 0 iff they are the same.
- */
-static int compare(FILE *fp0, FILE *fp1) {
- int result = 0;
- while (result == 0) {
- char b0[1024];
- char b1[1024];
- const size_t r0 = fread(b0, 1, sizeof(b0), fp0);
- const size_t r1 = fread(b1, 1, sizeof(b1), fp1);
-
- result = (int)r0 - (int)r1;
-
- if (0 == r0 || 0 == r1) break;
-
- if (0 == result) result = memcmp(b0, b1, r0);
- }
- return result;
-}
-
-/* Verify the input file is the same as the decompressed file. */
-static void verify(const char *inpFilename, const char *decFilename) {
- 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);
-}
-
-int main(int argc, const char *argv[]) {
- const char * const exeName = argv[0];
- char inpFilename[256] = { 0 };
- char ldmFilename[256] = { 0 };
- char decFilename[256] = { 0 };
-
- if (argc < 2) {
- printf("Wrong arguments\n");
- printf("Usage:\n");
- printf("%s FILE\n", exeName);
- return 1;
- }
-
- 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 */
- {
- struct timeval tv1, tv2;
- gettimeofday(&tv1, NULL);
- if (compress(inpFilename, ldmFilename)) {
- printf("Compress error");
- return 1;
- }
- gettimeofday(&tv2, NULL);
- printf("Total time = %f seconds\n",
- (double) (tv2.tv_usec - tv1.tv_usec) / 1000000 +
- (double) (tv2.tv_sec - tv1.tv_sec));
- }
-
- /* Decompress */
- {
- struct timeval tv1, tv2;
- gettimeofday(&tv1, NULL);
- if (decompress(ldmFilename, decFilename)) {
- printf("Decompress error");
- return 1;
- }
- gettimeofday(&tv2, NULL);
- printf("Total time = %f seconds\n",
- (double) (tv2.tv_usec - tv1.tv_usec) / 1000000 +
- (double) (tv2.tv_sec - tv1.tv_sec));
- }
- /* verify */
- verify(inpFilename, decFilename);
- return 0;
-}
-
-
-#if 0
-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
-
+++ /dev/null
-#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);
-}
-
-
+++ /dev/null
-#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);
-
-
-#endif /* LDM_UTIL_H */
+++ /dev/null
-# ################################################################
-# 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`
-
-CPPFLAGS+= -I../../lib/common
-CFLAGS ?= -O3
-DEBUGFLAGS = -Wall -Wextra -Wcast-qual -Wcast-align -Wshadow \
- -Wstrict-aliasing=1 -Wswitch-enum -Wdeclaration-after-statement \
- -Wstrict-prototypes -Wundef -Wpointer-arith -Wformat-security \
- -Wvla -Wformat=2 -Winit-self -Wfloat-equal -Wwrite-strings \
- -Wredundant-decls
-CFLAGS += $(DEBUGFLAGS) $(MOREFLAGS)
-FLAGS = $(CPPFLAGS) $(CFLAGS)
-
-LDFLAGS += -lzstd
-
-.PHONY: default all clean
-
-default: all
-
-all: main-ldm
-
-main-ldm : ldm.h ldm.c main-ldm.c
- $(CC) $(CPPFLAGS) $(CFLAGS) $^ $(LDFLAGS) -o $@
-
-clean:
- @rm -f core *.o tmp* result* *.ldm *.ldm.dec \
- main main-ldm
- @echo Cleaning completed
-
+++ /dev/null
-This version uses simple lz4-style compression with a rolling hash.
-- A rolling checksum based on rsync's Adler-32 style checksum is used.
-- The checksum is hashed using lz4's hash function.
-- Hash table replacement policy: direct overwrite.
-- The length of input to the hash function can be set with LDM_HASH_LENGTH.
+++ /dev/null
-#include <limits.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "ldm.h"
-
-// Insert every (HASH_ONLY_EVERY + 1) into the hash table.
-#define HASH_ONLY_EVERY 0
-
-#define ML_BITS 4
-#define ML_MASK ((1U<<ML_BITS)-1)
-#define RUN_BITS (8-ML_BITS)
-#define RUN_MASK ((1U<<RUN_BITS)-1)
-
-#define COMPUTE_STATS
-#define CHECKSUM_CHAR_OFFSET 10
-//#define RUN_CHECKS
-//#define LDM_DEBUG
-
-struct LDM_hashEntry {
- offset_t offset;
-};
-
-typedef struct LDM_hashTable {
- U32 numEntries;
- U32 minimumTagMask; // TODO: what if tag == offset?
-
- // Maximum number of elements in the table.
- U32 limit;
-
- LDM_hashEntry *entries;
-} LDM_hashTable;
-
-// TODO: Add offset histogram by powers of two
-// TODO: Scanning speed
-// TODO: Memory usage
-struct LDM_compressStats {
- U32 windowSizeLog, hashTableSizeLog;
- U32 numMatches;
- U64 totalMatchLength;
- U64 totalLiteralLength;
- U64 totalOffset;
-
- U32 minOffset, maxOffset;
-
- U32 numCollisions;
- U32 numHashInserts;
-
- U32 offsetHistogram[32];
-};
-
-struct LDM_CCtx {
- U64 isize; /* Input size */
- U64 maxOSize; /* Maximum output size */
-
- const BYTE *ibase; /* Base of input */
- const BYTE *ip; /* Current input position */
- const BYTE *iend; /* End of input */
-
- // Maximum input position such that hashing at the position does not exceed
- // end of input.
- const BYTE *ihashLimit;
-
- // Maximum input position such that finding a match of at least the minimum
- // match length does not exceed end of input.
- const BYTE *imatchLimit;
-
- const BYTE *obase; /* Base of output */
- BYTE *op; /* Output */
-
- const BYTE *anchor; /* Anchor to start of current (match) block */
-
- LDM_compressStats stats; /* Compression statistics */
-
- LDM_hashEntry *hashTable;
-
-// LDM_hashEntry hashTable[LDM_HASHTABLESIZE_U32];
-
- const BYTE *lastPosHashed; /* Last position hashed */
- hash_t lastHash; /* Hash corresponding to lastPosHashed */
- U32 lastSum;
-
- const BYTE *nextIp; // TODO: this is redundant (ip + step)
- const BYTE *nextPosHashed;
- hash_t nextHash; /* Hash corresponding to nextPosHashed */
- U32 nextSum;
-
- unsigned step; // ip step, should be 1.
-
- // DEBUG
- const BYTE *DEBUG_setNextHash;
-};
-
-void LDM_outputHashTableOccupancy(
- const LDM_hashEntry *hashTable, U32 hashTableSize) {
- U32 i = 0;
- U32 ctr = 0;
- for (; i < hashTableSize; i++) {
- 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);
-}
-
-// TODO: This can be done more efficiently (but it is not that important as it
-// is only used for computing stats).
-static int intLog2(U32 x) {
- int ret = 0;
- while (x >>= 1) {
- ret++;
- }
- return ret;
-}
-
-// TODO: Maybe we would eventually prefer to have linear rather than
-// exponential buckets.
-void LDM_outputHashTableOffsetHistogram(const LDM_CCtx *cctx) {
- int i = 0;
- int buckets[32] = { 0 };
-
- printf("\n");
- printf("Hash table histogram\n");
- for (; i < LDM_HASHTABLESIZE_U32; i++) {
- int offset = (cctx->ip - cctx->ibase) - cctx->hashTable[i].offset;
- buckets[intLog2(offset)]++;
- }
-
- i = 0;
- for (; i < 32; i++) {
- printf("2^%*d: %10u %6.3f%%\n", 2, i,
- buckets[i],
- 100.0 * (double) buckets[i] /
- (double) LDM_HASHTABLESIZE_U32);
- }
- printf("\n");
-}
-
-void LDM_printCompressStats(const LDM_compressStats *stats) {
- int i = 0;
- printf("=====================\n");
- printf("Compression statistics\n");
- //TODO: compute percentage matched?
- printf("Window size, hash table size (bytes): 2^%u, 2^%u\n",
- stats->windowSizeLog, stats->hashTableSizeLog);
- 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, total literalLength: %.1f, %llu\n",
- ((double)stats->totalLiteralLength) / (double)stats->numMatches,
- stats->totalLiteralLength);
- 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("\n");
- printf("offset histogram: offset, num matches, %% of matches\n");
-
- for (; i <= intLog2(stats->maxOffset); i++) {
- printf("2^%*d: %10u %6.3f%%\n", 2, i,
- stats->offsetHistogram[i],
- 100.0 * (double) stats->offsetHistogram[i] /
- (double) stats->numMatches);
- }
- printf("\n");
-
-
- 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);
- printf("=====================\n");
-
-}
-
-int LDM_isValidMatch(const BYTE *pIn, const BYTE *pMatch) {
- /*
- if (memcmp(pIn, pMatch, LDM_MIN_MATCH_LENGTH) == 0) {
- return 1;
- }
- return 0;
- */
-
- //TODO: This seems to be faster for some reason?
- U32 lengthLeft = LDM_MIN_MATCH_LENGTH;
- const BYTE *curIn = pIn;
- const BYTE *curMatch = pMatch;
-
- for (; lengthLeft >= 8; lengthLeft -= 8) {
- if (MEM_read64(curIn) != MEM_read64(curMatch)) {
- return 0;
- }
- curIn += 8;
- curMatch += 8;
- }
- if (lengthLeft > 0) {
- return (MEM_read32(curIn) == MEM_read32(curMatch));
- }
- return 1;
-}
-
-/**
- * Convert a sum computed from getChecksum to a hash value in the range
- * of the hash table.
- */
-static hash_t checksumToHash(U32 sum) {
- return ((sum * 2654435761U) >> (32 - LDM_HASHLOG));
-}
-
-/**
- * Computes a checksum based on rsync's checksum.
- *
- * a(k,l) = \sum_{i = k}^l 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)
- */
-static U32 getChecksum(const BYTE *buf, U32 len) {
- U32 i;
- U32 s1, s2;
-
- s1 = s2 = 0;
- for (i = 0; i < (len - 4); i += 4) {
- s2 += (4 * (s1 + buf[i])) + (3 * buf[i + 1]) +
- (2 * 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++) {
- s1 += buf[i] + CHECKSUM_CHAR_OFFSET;
- s2 += s1;
- }
- return (s1 & 0xffff) + (s2 << 16);
-}
-
-/**
- * Update a checksum computed from getChecksum(data, len).
- *
- * The checksum can be updated along its ends as follows:
- * a(k+1, l+1) = (a(k,l) - x_k + x_{l+1}) (mod M)
- * b(k+1, l+1) = (b(k,l) - (l-k+1)*x_k + (a(k+1,l+1)) (mod M)
- *
- * Thus toRemove should correspond to data[0].
- */
-static U32 updateChecksum(U32 sum, U32 len,
- BYTE toRemove, BYTE toAdd) {
- U32 s1 = (sum & 0xffff) - toRemove + toAdd;
- U32 s2 = (sum >> 16) - ((toRemove + CHECKSUM_CHAR_OFFSET) * len) + s1;
-
- return (s1 & 0xffff) + (s2 << 16);
-}
-
-/**
- * Update cctx->nextSum, cctx->nextHash, and cctx->nextPosHashed
- * based on cctx->lastSum and cctx->lastPosHashed.
- *
- * This uses a rolling hash and requires that the last position hashed
- * corresponds to cctx->nextIp - step.
- */
-static void setNextHash(LDM_CCtx *cctx) {
-#ifdef RUN_CHECKS
- U32 check;
- if ((cctx->nextIp - cctx->ibase != 1) &&
- (cctx->nextIp - cctx->DEBUG_setNextHash != 1)) {
- printf("CHECK debug fail: %zu %zu\n", cctx->nextIp - cctx->ibase,
- cctx->DEBUG_setNextHash - cctx->ibase);
- }
-
- cctx->DEBUG_setNextHash = cctx->nextIp;
-#endif
-
-// cctx->nextSum = getChecksum((const char *)cctx->nextIp, LDM_HASH_LENGTH);
- cctx->nextSum = updateChecksum(
- cctx->lastSum, LDM_HASH_LENGTH,
- cctx->lastPosHashed[0],
- cctx->lastPosHashed[LDM_HASH_LENGTH]);
- cctx->nextPosHashed = cctx->nextIp;
- cctx->nextHash = checksumToHash(cctx->nextSum);
-
-#ifdef RUN_CHECKS
- check = getChecksum(cctx->nextIp, LDM_HASH_LENGTH);
-
- if (check != cctx->nextSum) {
- printf("CHECK: setNextHash failed %u %u\n", check, cctx->nextSum);
- }
-
- if ((cctx->nextIp - cctx->lastPosHashed) != 1) {
- printf("setNextHash: nextIp != lastPosHashed + 1. %zu %zu %zu\n",
- cctx->nextIp - cctx->ibase, cctx->lastPosHashed - cctx->ibase,
- cctx->ip - cctx->ibase);
- }
-#endif
-}
-
-static void putHashOfCurrentPositionFromHash(
- LDM_CCtx *cctx, hash_t hash, U32 sum) {
-#ifdef COMPUTE_STATS
- if (cctx->stats.numHashInserts < LDM_HASHTABLESIZE_U32) {
- offset_t offset = cctx->hashTable[hash].offset;
- cctx->stats.numHashInserts++;
- if (offset != 0 && !LDM_isValidMatch(cctx->ip, offset + cctx->ibase)) {
- cctx->stats.numCollisions++;
- }
- }
-#endif
-
- // Hash only every HASH_ONLY_EVERY times, based on cctx->ip.
- // Note: this works only when cctx->step is 1.
- if (((cctx->ip - cctx->ibase) & HASH_ONLY_EVERY) == HASH_ONLY_EVERY) {
- const LDM_hashEntry entry = { cctx->ip - cctx->ibase };
- cctx->hashTable[hash] = entry;
- }
-
- cctx->lastPosHashed = cctx->ip;
- cctx->lastHash = hash;
- cctx->lastSum = sum;
-}
-
-/**
- * Copy over the cctx->lastHash, cctx->lastSum, and cctx->lastPosHashed
- * fields from the "next" fields.
- *
- * This requires that cctx->ip == cctx->nextPosHashed.
- */
-static void LDM_updateLastHashFromNextHash(LDM_CCtx *cctx) {
-#ifdef RUN_CHECKS
- if (cctx->ip != cctx->nextPosHashed) {
- printf("CHECK failed: updateLastHashFromNextHash %zu\n",
- cctx->ip - cctx->ibase);
- }
-#endif
- putHashOfCurrentPositionFromHash(cctx, cctx->nextHash, cctx->nextSum);
-}
-
-/**
- * Insert hash of the current position into the hash table.
- */
-static void LDM_putHashOfCurrentPosition(LDM_CCtx *cctx) {
- U32 sum = getChecksum(cctx->ip, LDM_HASH_LENGTH);
- hash_t hash = checksumToHash(sum);
-
-#ifdef RUN_CHECKS
- if (cctx->nextPosHashed != cctx->ip && (cctx->ip != cctx->ibase)) {
- printf("CHECK failed: putHashOfCurrentPosition %zu\n",
- cctx->ip - cctx->ibase);
- }
-#endif
-
- putHashOfCurrentPositionFromHash(cctx, hash, sum);
-}
-
-/**
- * Returns the position of the entry at hashTable[hash].
- */
-static const BYTE *getPositionOnHash(LDM_CCtx *cctx, hash_t hash) {
- return cctx->hashTable[hash].offset + cctx->ibase;
-}
-
-U32 LDM_countMatchLength(const BYTE *pIn, const BYTE *pMatch,
- const BYTE *pInLimit) {
- const BYTE * const pStart = pIn;
- while (pIn < pInLimit - 1) {
- BYTE const diff = (*pMatch) ^ *(pIn);
- if (!diff) {
- pIn++;
- pMatch++;
- continue;
- }
- return (U32)(pIn - pStart);
- }
- return (U32)(pIn - pStart);
-}
-
-void LDM_readHeader(const void *src, U64 *compressedSize,
- U64 *decompressedSize) {
- const BYTE *ip = (const BYTE *)src;
- *compressedSize = MEM_readLE64(ip);
- ip += sizeof(U64);
- *decompressedSize = MEM_readLE64(ip);
- // ip += sizeof(U64);
-}
-
-void LDM_initializeCCtx(LDM_CCtx *cctx,
- const void *src, size_t srcSize,
- void *dst, size_t maxDstSize) {
- cctx->isize = srcSize;
- cctx->maxOSize = maxDstSize;
-
- cctx->ibase = (const BYTE *)src;
- cctx->ip = cctx->ibase;
- cctx->iend = cctx->ibase + srcSize;
-
- cctx->ihashLimit = cctx->iend - LDM_HASH_LENGTH;
- cctx->imatchLimit = cctx->iend - LDM_MIN_MATCH_LENGTH;
-
- cctx->obase = (BYTE *)dst;
- cctx->op = (BYTE *)dst;
-
- cctx->anchor = cctx->ibase;
-
- memset(&(cctx->stats), 0, sizeof(cctx->stats));
- cctx->hashTable = calloc(LDM_HASHTABLESIZE_U32, sizeof(LDM_hashEntry));
-// memset(cctx->hashTable, 0, sizeof(cctx->hashTable));
- cctx->stats.minOffset = UINT_MAX;
- cctx->stats.windowSizeLog = LDM_WINDOW_SIZE_LOG;
- cctx->stats.hashTableSizeLog = LDM_MEMORY_USAGE;
-
-
- cctx->lastPosHashed = NULL;
-
- cctx->step = 1; // Fixed to be 1 for now. Changing may break things.
- cctx->nextIp = cctx->ip + cctx->step;
- cctx->nextPosHashed = 0;
-
- cctx->DEBUG_setNextHash = 0;
-}
-
-void LDM_destroyCCtx(LDM_CCtx *cctx) {
- free(cctx->hashTable);
-}
-
-/**
- * Finds the "best" match.
- *
- * Returns 0 if successful and 1 otherwise (i.e. no match can be found
- * in the remaining input that is long enough).
- *
- */
-static int LDM_findBestMatch(LDM_CCtx *cctx, const BYTE **match) {
- cctx->nextIp = cctx->ip + cctx->step;
-
- do {
- hash_t h;
- U32 sum;
- setNextHash(cctx);
- h = cctx->nextHash;
- sum = cctx->nextSum;
- cctx->ip = cctx->nextIp;
- cctx->nextIp += cctx->step;
-
- if (cctx->ip > cctx->imatchLimit) {
- return 1;
- }
-
- *match = getPositionOnHash(cctx, h);
- putHashOfCurrentPositionFromHash(cctx, h, sum);
-
- } while (cctx->ip - *match > LDM_WINDOW_SIZE ||
- !LDM_isValidMatch(cctx->ip, *match));
- setNextHash(cctx);
- return 0;
-}
-
-void LDM_encodeLiteralLengthAndLiterals(
- LDM_CCtx *cctx, BYTE *pToken, const U32 literalLength) {
- /* Encode the literal length. */
- if (literalLength >= RUN_MASK) {
- int len = (int)literalLength - RUN_MASK;
- *pToken = (RUN_MASK << ML_BITS);
- for (; len >= 255; len -= 255) {
- *(cctx->op)++ = 255;
- }
- *(cctx->op)++ = (BYTE)len;
- } else {
- *pToken = (BYTE)(literalLength << ML_BITS);
- }
-
- /* Encode the literals. */
- memcpy(cctx->op, cctx->anchor, 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. */
- MEM_write32(cctx->op, offset);
- cctx->op += LDM_OFFSET_SIZE;
-
- /* Encode the match length. */
- if (matchLength >= ML_MASK) {
- unsigned matchLengthRemaining = matchLength;
- *pToken += ML_MASK;
- matchLengthRemaining -= ML_MASK;
- MEM_write32(cctx->op, 0xFFFFFFFF);
- while (matchLengthRemaining >= 4*0xFF) {
- cctx->op += 4;
- MEM_write32(cctx->op, 0xffffffff);
- matchLengthRemaining -= 4*0xFF;
- }
- cctx->op += matchLengthRemaining / 255;
- *(cctx->op)++ = (BYTE)(matchLengthRemaining % 255);
- } else {
- *pToken += (BYTE)(matchLength);
- }
-}
-
-// 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,
- void *dst, size_t maxDstSize) {
- LDM_CCtx cctx;
- const BYTE *match;
- LDM_initializeCCtx(&cctx, src, srcSize, dst, maxDstSize);
-
- /* Hash the first position and put it into the hash table. */
- LDM_putHashOfCurrentPosition(&cctx);
-
- /**
- * Find a match.
- * If no more matches can be found (i.e. the length of the remaining input
- * is less than the minimum match length), then stop searching for matches
- * and encode the final literals.
- */
- while (LDM_findBestMatch(&cctx, &match) == 0) {
-#ifdef COMPUTE_STATS
- cctx.stats.numMatches++;
-#endif
-
- /**
- * Catch up: look back to extend the match backwards from the found match.
- */
- while (cctx.ip > cctx.anchor && match > cctx.ibase &&
- cctx.ip[-1] == match[-1]) {
- cctx.ip--;
- match--;
- }
-
- /**
- * Write current block (literals, literal length, match offset, match
- * length) and update pointers and hashes.
- */
- {
- const U32 literalLength = cctx.ip - cctx.anchor;
- const U32 offset = cctx.ip - match;
- const U32 matchLength = LDM_countMatchLength(
- cctx.ip + LDM_MIN_MATCH_LENGTH, match + LDM_MIN_MATCH_LENGTH,
- cctx.ihashLimit);
-
- LDM_outputBlock(&cctx, literalLength, offset, matchLength);
-
-#ifdef COMPUTE_STATS
- cctx.stats.totalLiteralLength += literalLength;
- cctx.stats.totalOffset += offset;
- 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;
- cctx.stats.offsetHistogram[(U32)intLog2(offset)]++;
-#endif
-
- // Move ip to end of block, inserting hashes at each position.
- cctx.nextIp = cctx.ip + cctx.step;
- while (cctx.ip < cctx.anchor + LDM_MIN_MATCH_LENGTH +
- matchLength + literalLength) {
- if (cctx.ip > cctx.lastPosHashed) {
- // TODO: Simplify.
- LDM_updateLastHashFromNextHash(&cctx);
- setNextHash(&cctx);
- }
- cctx.ip++;
- cctx.nextIp++;
- }
- }
-
- // Set start of next block to current input pointer.
- cctx.anchor = cctx.ip;
- LDM_updateLastHashFromNextHash(&cctx);
- }
-
- // LDM_outputHashTableOffsetHistogram(&cctx);
-
- /* Encode the last literals (no more matches). */
- {
- const size_t lastRun = cctx.iend - cctx.anchor;
- BYTE *pToken = cctx.op++;
- LDM_encodeLiteralLengthAndLiterals(&cctx, pToken, lastRun);
- }
-
-#ifdef COMPUTE_STATS
- LDM_printCompressStats(&cctx.stats);
- LDM_outputHashTableOccupancy(cctx.hashTable, LDM_HASHTABLESIZE_U32);
-#endif
-
- {
- const size_t ret = cctx.op - cctx.obase;
- LDM_destroyCCtx(&cctx);
- return ret;
- }
-}
-
-struct LDM_DCtx {
- size_t compressedSize;
- size_t maxDecompressedSize;
-
- const BYTE *ibase; /* Base of input */
- const BYTE *ip; /* Current input position */
- const BYTE *iend; /* End of source */
-
- const BYTE *obase; /* Base of output */
- BYTE *op; /* Current output position */
- const BYTE *oend; /* End of output */
-};
-
-void LDM_initializeDCtx(LDM_DCtx *dctx,
- const void *src, size_t compressedSize,
- void *dst, size_t maxDecompressedSize) {
- dctx->compressedSize = compressedSize;
- dctx->maxDecompressedSize = maxDecompressedSize;
-
- dctx->ibase = src;
- dctx->ip = (const BYTE *)src;
- dctx->iend = dctx->ip + dctx->compressedSize;
- dctx->op = dst;
- dctx->oend = dctx->op + dctx->maxDecompressedSize;
-}
-
-size_t LDM_decompress(const void *src, size_t compressedSize,
- void *dst, size_t maxDecompressedSize) {
- LDM_DCtx dctx;
- LDM_initializeDCtx(&dctx, src, compressedSize, dst, maxDecompressedSize);
-
- while (dctx.ip < dctx.iend) {
- BYTE *cpy;
- const BYTE *match;
- size_t length, offset;
-
- /* Get the literal length. */
- const unsigned token = *(dctx.ip)++;
- if ((length = (token >> ML_BITS)) == RUN_MASK) {
- unsigned s;
- do {
- s = *(dctx.ip)++;
- length += s;
- } while (s == 255);
- }
-
- /* Copy the literals. */
- cpy = dctx.op + length;
- memcpy(dctx.op, dctx.ip, length);
- dctx.ip += length;
- dctx.op = cpy;
-
- //TODO : dynamic offset size
- offset = MEM_read32(dctx.ip);
- dctx.ip += LDM_OFFSET_SIZE;
- match = dctx.op - offset;
-
- /* Get the match length. */
- length = token & ML_MASK;
- if (length == ML_MASK) {
- unsigned s;
- do {
- s = *(dctx.ip)++;
- length += s;
- } while (s == 255);
- }
- length += LDM_MIN_MATCH_LENGTH;
-
- /* Copy match. */
- cpy = dctx.op + length;
-
- // Inefficient for now.
- while (match < cpy - offset && dctx.op < dctx.oend) {
- *(dctx.op)++ = *match++;
- }
- }
- 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 *dst, size_t maxDstSize) {
- const BYTE *ip = (const BYTE *)src + 1125;
- U32 sum = getChecksum((const char *)ip, LDM_HASH_LENGTH);
- U32 sum2;
- ++ip;
- for (; ip < (const BYTE *)src + 1125 + 100; ip++) {
- sum2 = updateChecksum(sum, LDM_HASH_LENGTH,
- ip[-1], ip[LDM_HASH_LENGTH - 1]);
- sum = getChecksum((const char *)ip, LDM_HASH_LENGTH);
- printf("TEST HASH: %zu %u %u\n", ip - (const BYTE *)src, sum, sum2);
- }
-}
-*/
-
-
+++ /dev/null
-#ifndef LDM_H
-#define LDM_H
-
-#include <stddef.h> /* size_t */
-
-#include "mem.h" // from /lib/common/mem.h
-
-#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 16
-#define LDM_HASHLOG (LDM_MEMORY_USAGE-2)
-#define LDM_HASHTABLESIZE (1 << (LDM_MEMORY_USAGE))
-#define LDM_HASHTABLESIZE_U32 ((LDM_HASHTABLESIZE) >> 2)
-
-#define LDM_WINDOW_SIZE_LOG 25
-#define LDM_WINDOW_SIZE (1 << (LDM_WINDOW_SIZE_LOG))
-
-//These should be multiples of four.
-#define LDM_MIN_MATCH_LENGTH 4
-#define LDM_HASH_LENGTH 4
-
-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,
- void *dst, size_t maxDstSize);
-
-/**
- * Initialize the compression context.
- *
- * Allocates memory for the hash table.
- */
-void LDM_initializeCCtx(LDM_CCtx *cctx,
- const void *src, size_t srcSize,
- void *dst, size_t maxDstSize);
-
-/**
- * Frees up memory allocating in initializeCCtx
- */
-void LDM_destroyCCtx(LDM_CCtx *cctx);
-
-/**
- * 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);
-
-/**
- * Prints the distribution of offsets in the hash table.
- *
- * The offsets are defined as the distance of the hash table entry from the
- * current input position of the cctx.
- */
-void LDM_outputHashTableOffsetHistogram(const LDM_CCtx *cctx);
-
-/**
- * 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,
- void *dst, size_t maxDstSize);
-
-/**
- * Initialize the decompression context.
- */
-void LDM_initializeDCtx(LDM_DCtx *dctx,
- const void *src, size_t compressedSize,
- void *dst, size_t maxDecompressedSize);
-
-/**
- * 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 */
+++ /dev/null
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <sys/time.h>
-#include <sys/types.h>
-#include <sys/mman.h>
-#include <sys/stat.h>
-#include <unistd.h>
-#include <zstd.h>
-
-#include <fcntl.h>
-#include "ldm.h"
-#include "zstd.h"
-
-#define DEBUG
-#define TEST
-
-/* Compress file given by fname and output to oname.
- * 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) {
- int fdin, fdout;
- struct stat statbuf;
- char *src, *dst;
- size_t maxCompressedSize, compressedSize;
-
- /* Open the input file. */
- if ((fdin = open(fname, O_RDONLY)) < 0) {
- perror("Error in file opening");
- return 1;
- }
-
- /* Open the output file. */
- if ((fdout = open(oname, O_RDWR | O_CREAT | O_TRUNC, (mode_t)0600)) < 0) {
- perror("Can't create output file");
- return 1;
- }
-
- /* Find the size of the input file. */
- if (fstat (fdin, &statbuf) < 0) {
- perror("Fstat error");
- return 1;
- }
-
- maxCompressedSize = statbuf.st_size + LDM_HEADER_SIZE;
-
- /* Go to the location corresponding to the last byte. */
- /* TODO: fallocate? */
- if (lseek(fdout, maxCompressedSize - 1, SEEK_SET) == -1) {
- perror("lseek error");
- return 1;
- }
-
- /* Write a dummy byte at the last location. */
- if (write(fdout, "", 1) != 1) {
- perror("write error");
- return 1;
- }
-
- /* mmap the input file. */
- if ((src = mmap(0, statbuf.st_size, PROT_READ, MAP_SHARED, fdin, 0))
- == (caddr_t) - 1) {
- perror("mmap error for input");
- return 1;
- }
-
- /* mmap the output file */
- if ((dst = mmap(0, maxCompressedSize, PROT_READ | PROT_WRITE,
- MAP_SHARED, fdout, 0)) == (caddr_t) - 1) {
- perror("mmap error for output");
- return 1;
- }
-
- compressedSize = LDM_HEADER_SIZE +
- LDM_compress(src, statbuf.st_size,
- dst + LDM_HEADER_SIZE, maxCompressedSize);
-
- // Write compress and decompress size to header
- // TODO: should depend on LDM_DECOMPRESS_SIZE write32
- memcpy(dst, &compressedSize, 8);
- memcpy(dst + 8, &(statbuf.st_size), 8);
-
-#ifdef DEBUG
- printf("Compressed size: %zu\n", compressedSize);
- printf("Decompressed size: %zu\n", (size_t)statbuf.st_size);
-#endif
-
- // Truncate file to compressedSize.
- ftruncate(fdout, compressedSize);
-
- printf("%25s : %6u -> %7u - %s (%.1f%%)\n", fname,
- (unsigned)statbuf.st_size, (unsigned)compressedSize, oname,
- (double)compressedSize / (statbuf.st_size) * 100);
-
- // Close files.
- close(fdin);
- close(fdout);
- return 0;
-}
-
-/* Decompress file compressed using LDM_compress.
- * The input file should have the LDM_HEADER followed by payload.
- * Returns 0 if succesful, and an error code otherwise.
- */
-static int decompress(const char *fname, const char *oname) {
- int fdin, fdout;
- struct stat statbuf;
- char *src, *dst;
- U64 compressedSize, decompressedSize;
- size_t outSize;
-
- /* Open the input file. */
- if ((fdin = open(fname, O_RDONLY)) < 0) {
- perror("Error in file opening");
- return 1;
- }
-
- /* Open the output file. */
- if ((fdout = open(oname, O_RDWR | O_CREAT | O_TRUNC, (mode_t)0600)) < 0) {
- perror("Can't create output file");
- return 1;
- }
-
- /* Find the size of the input file. */
- if (fstat (fdin, &statbuf) < 0) {
- perror("Fstat error");
- return 1;
- }
-
- /* mmap the input file. */
- if ((src = mmap(0, statbuf.st_size, PROT_READ, MAP_SHARED, fdin, 0))
- == (caddr_t) - 1) {
- perror("mmap error for input");
- return 1;
- }
-
- /* Read the header. */
- LDM_readHeader(src, &compressedSize, &decompressedSize);
-
- /* Go to the location corresponding to the last byte. */
- if (lseek(fdout, decompressedSize - 1, SEEK_SET) == -1) {
- perror("lseek error");
- return 1;
- }
-
- /* write a dummy byte at the last location */
- if (write(fdout, "", 1) != 1) {
- perror("write error");
- return 1;
- }
-
- /* mmap the output file */
- if ((dst = mmap(0, decompressedSize, PROT_READ | PROT_WRITE,
- MAP_SHARED, fdout, 0)) == (caddr_t) - 1) {
- perror("mmap error for output");
- return 1;
- }
-
- outSize = LDM_decompress(
- src + LDM_HEADER_SIZE, statbuf.st_size - LDM_HEADER_SIZE,
- dst, decompressedSize);
-
- printf("Ret size out: %zu\n", outSize);
- ftruncate(fdout, outSize);
-
- close(fdin);
- close(fdout);
- return 0;
-}
-
-/* Compare two files.
- * Returns 0 iff they are the same.
- */
-static int compare(FILE *fp0, FILE *fp1) {
- int result = 0;
- while (result == 0) {
- char b0[1024];
- char b1[1024];
- const size_t r0 = fread(b0, 1, sizeof(b0), fp0);
- const size_t r1 = fread(b1, 1, sizeof(b1), fp1);
-
- result = (int)r0 - (int)r1;
-
- if (0 == r0 || 0 == r1) break;
-
- if (0 == result) result = memcmp(b0, b1, r0);
- }
- return result;
-}
-
-/* Verify the input file is the same as the decompressed file. */
-static void verify(const char *inpFilename, const char *decFilename) {
- 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);
-}
-
-int main(int argc, const char *argv[]) {
- const char * const exeName = argv[0];
- char inpFilename[256] = { 0 };
- char ldmFilename[256] = { 0 };
- char decFilename[256] = { 0 };
-
- if (argc < 2) {
- printf("Wrong arguments\n");
- printf("Usage:\n");
- printf("%s FILE\n", exeName);
- return 1;
- }
-
- 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 */
- {
- struct timeval tv1, tv2;
- gettimeofday(&tv1, NULL);
- if (compress(inpFilename, ldmFilename)) {
- printf("Compress error");
- return 1;
- }
- gettimeofday(&tv2, NULL);
- printf("Total compress time = %f seconds\n",
- (double) (tv2.tv_usec - tv1.tv_usec) / 1000000 +
- (double) (tv2.tv_sec - tv1.tv_sec));
- }
-
- /* Decompress */
- {
- struct timeval tv1, tv2;
- gettimeofday(&tv1, NULL);
- if (decompress(ldmFilename, decFilename)) {
- printf("Decompress error");
- return 1;
- }
- gettimeofday(&tv2, NULL);
- printf("Total decompress time = %f seconds\n",
- (double) (tv2.tv_usec - tv1.tv_usec) / 1000000 +
- (double) (tv2.tv_sec - tv1.tv_sec));
- }
- /* verify */
- verify(inpFilename, decFilename);
-
-#ifdef TEST
- LDM_test();
-#endif
- return 0;
-}
projects / thirdparty / zstd.git / commitdiff
