Andrew's git - gitweb.git/blob

   1/*
   2 * diff-delta.c: generate a delta between two buffers
   3 *
   4 *  Many parts of this file have been lifted from LibXDiff version 0.10.
   5 *  http://www.xmailserver.org/xdiff-lib.html
   6 *
   7 *  LibXDiff was written by Davide Libenzi <davidel@xmailserver.org>
   8 *  Copyright (C) 2003  Davide Libenzi
   9 *
  10 *  Many mods for GIT usage by Nicolas Pitre <nico@cam.org>, (C) 2005.
  11 *
  12 *  This file is free software; you can redistribute it and/or
  13 *  modify it under the terms of the GNU Lesser General Public
  14 *  License as published by the Free Software Foundation; either
  15 *  version 2.1 of the License, or (at your option) any later version.
  16 *
  17 *  Use of this within git automatically means that the LGPL
  18 *  licensing gets turned into GPLv2 within this project.
  19 */
  20
  21#include <stdlib.h>
  22#include <string.h>
  23#include <zlib.h>
  24#include "delta.h"
  25
  26
  27/* block size: min = 16, max = 64k, power of 2 */
  28#define BLK_SIZE 16
  29
  30#define MIN(a, b) ((a) < (b) ? (a) : (b))
  31
  32#define GR_PRIME 0x9e370001
  33#define HASH(v, shift) (((unsigned int)(v) * GR_PRIME) >> (shift))
  34
  35struct index {
  36        const unsigned char *ptr;
  37        unsigned int val;
  38        struct index *next;
  39};
  40
  41static struct index ** delta_index(const unsigned char *buf,
  42                                   unsigned long bufsize,
  43                                   unsigned long trg_bufsize,
  44                                   unsigned int *hash_shift)
  45{
  46        unsigned int i, hsize, hshift, hlimit, entries, *hash_count;
  47        const unsigned char *data;
  48        struct index *entry, **hash;
  49        void *mem;
  50
  51        /* determine index hash size */
  52        entries = bufsize  / BLK_SIZE;
  53        hsize = entries / 4;
  54        for (i = 4; (1 << i) < hsize && i < 31; i++);
  55        hsize = 1 << i;
  56        hshift = 32 - i;
  57        *hash_shift = hshift;
  58
  59        /* allocate lookup index */
  60        mem = malloc(hsize * sizeof(*hash) + entries * sizeof(*entry));
  61        if (!mem)
  62                return NULL;
  63        hash = mem;
  64        entry = mem + hsize * sizeof(*hash);
  65        memset(hash, 0, hsize * sizeof(*hash));
  66
  67        /* allocate an array to count hash entries */
  68        hash_count = calloc(hsize, sizeof(*hash_count));
  69        if (!hash_count) {
  70                free(hash);
  71                return NULL;
  72        }
  73
  74        /* then populate the index */
  75        data = buf + entries * BLK_SIZE - BLK_SIZE;
  76        while (data >= buf) {
  77                unsigned int val = adler32(0, data, BLK_SIZE);
  78                i = HASH(val, hshift);
  79                entry->ptr = data;
  80                entry->val = val;
  81                entry->next = hash[i];
  82                hash[i] = entry++;
  83                hash_count[i]++;
  84                data -= BLK_SIZE;
  85        }
  86
  87        /*
  88         * Determine a limit on the number of entries in the same hash
  89         * bucket.  This guard us against patological data sets causing
  90         * really bad hash distribution with most entries in the same hash
  91         * bucket that would bring us to O(m*n) computing costs (m and n
  92         * corresponding to reference and target buffer sizes).
  93         *
  94         * The more the target buffer is large, the more it is important to
  95         * have small entry lists for each hash buckets.  With such a limit
  96         * the cost is bounded to something more like O(m+n).
  97         */
  98        hlimit = (1 << 26) / trg_bufsize;
  99        if (hlimit < 4*BLK_SIZE)
 100                hlimit = 4*BLK_SIZE;
 101
 102        /*
 103         * Now make sure none of the hash buckets has more entries than
 104         * we're willing to test.  Otherwise we cull the entry list
 105         * uniformly to still preserve a good repartition across
 106         * the reference buffer.
 107         */
 108        for (i = 0; i < hsize; i++) {
 109                if (hash_count[i] < hlimit)
 110                        continue;
 111                entry = hash[i];
 112                do {
 113                        struct index *keep = entry;
 114                        int skip = hash_count[i] / hlimit / 2;
 115                        do {
 116                                entry = entry->next;
 117                        } while(--skip && entry);
 118                        keep->next = entry;
 119                } while(entry);
 120        }
 121        free(hash_count);
 122
 123        return hash;
 124}
 125
 126/* provide the size of the copy opcode given the block offset and size */
 127#define COPYOP_SIZE(o, s) \
 128    (!!(o & 0xff) + !!(o & 0xff00) + !!(o & 0xff0000) + !!(o & 0xff000000) + \
 129     !!(s & 0xff) + !!(s & 0xff00) + 1)
 130
 131/* the maximum size for any opcode */
 132#define MAX_OP_SIZE COPYOP_SIZE(0xffffffff, 0xffffffff)
 133
 134void *diff_delta(const void *from_buf, unsigned long from_size,
 135                 const void *to_buf, unsigned long to_size,
 136                 unsigned long *delta_size,
 137                 unsigned long max_size)
 138{
 139        unsigned int i, outpos, outsize, hash_shift;
 140        int inscnt;
 141        const unsigned char *ref_data, *ref_top, *data, *top;
 142        unsigned char *out;
 143        struct index *entry, **hash;
 144
 145        if (!from_size || !to_size)
 146                return NULL;
 147        hash = delta_index(from_buf, from_size, to_size, &hash_shift);
 148        if (!hash)
 149                return NULL;
 150
 151        outpos = 0;
 152        outsize = 8192;
 153        if (max_size && outsize >= max_size)
 154                outsize = max_size + MAX_OP_SIZE + 1;
 155        out = malloc(outsize);
 156        if (!out) {
 157                free(hash);
 158                return NULL;
 159        }
 160
 161        ref_data = from_buf;
 162        ref_top = from_buf + from_size;
 163        data = to_buf;
 164        top = to_buf + to_size;
 165
 166        /* store reference buffer size */
 167        out[outpos++] = from_size;
 168        from_size >>= 7;
 169        while (from_size) {
 170                out[outpos - 1] |= 0x80;
 171                out[outpos++] = from_size;
 172                from_size >>= 7;
 173        }
 174
 175        /* store target buffer size */
 176        out[outpos++] = to_size;
 177        to_size >>= 7;
 178        while (to_size) {
 179                out[outpos - 1] |= 0x80;
 180                out[outpos++] = to_size;
 181                to_size >>= 7;
 182        }
 183
 184        inscnt = 0;
 185
 186        while (data < top) {
 187                unsigned int moff = 0, msize = 0;
 188                if (data + BLK_SIZE <= top) {
 189                        unsigned int val = adler32(0, data, BLK_SIZE);
 190                        i = HASH(val, hash_shift);
 191                        for (entry = hash[i]; entry; entry = entry->next) {
 192                                const unsigned char *ref = entry->ptr;
 193                                const unsigned char *src = data;
 194                                unsigned int ref_size = ref_top - ref;
 195                                if (entry->val != val)
 196                                        continue;
 197                                if (ref_size > top - src)
 198                                        ref_size = top - src;
 199                                if (ref_size > 0x10000)
 200                                        ref_size = 0x10000;
 201                                if (ref_size <= msize)
 202                                        break;
 203                                while (ref_size-- && *src++ == *ref)
 204                                        ref++;
 205                                if (msize < ref - entry->ptr) {
 206                                        /* this is our best match so far */
 207                                        msize = ref - entry->ptr;
 208                                        moff = entry->ptr - ref_data;
 209                                }
 210                        }
 211                }
 212
 213                if (!msize || msize < COPYOP_SIZE(moff, msize)) {
 214                        if (!inscnt)
 215                                outpos++;
 216                        out[outpos++] = *data++;
 217                        inscnt++;
 218                        if (inscnt == 0x7f) {
 219                                out[outpos - inscnt - 1] = inscnt;
 220                                inscnt = 0;
 221                        }
 222                } else {
 223                        unsigned char *op;
 224
 225                        if (inscnt) {
 226                                while (moff && ref_data[moff-1] == data[-1]) {
 227                                        if (msize == 0x10000)
 228                                                break;
 229                                        /* we can match one byte back */
 230                                        msize++;
 231                                        moff--;
 232                                        data--;
 233                                        outpos--;
 234                                        if (--inscnt)
 235                                                continue;
 236                                        outpos--;  /* remove count slot */
 237                                        inscnt--;  /* make it -1 */
 238                                        break;
 239                                }
 240                                out[outpos - inscnt - 1] = inscnt;
 241                                inscnt = 0;
 242                        }
 243
 244                        data += msize;
 245                        op = out + outpos++;
 246                        i = 0x80;
 247
 248                        if (moff & 0xff) { out[outpos++] = moff; i |= 0x01; }
 249                        moff >>= 8;
 250                        if (moff & 0xff) { out[outpos++] = moff; i |= 0x02; }
 251                        moff >>= 8;
 252                        if (moff & 0xff) { out[outpos++] = moff; i |= 0x04; }
 253                        moff >>= 8;
 254                        if (moff & 0xff) { out[outpos++] = moff; i |= 0x08; }
 255
 256                        if (msize & 0xff) { out[outpos++] = msize; i |= 0x10; }
 257                        msize >>= 8;
 258                        if (msize & 0xff) { out[outpos++] = msize; i |= 0x20; }
 259
 260                        *op = i;
 261                }
 262
 263                if (outpos >= outsize - MAX_OP_SIZE) {
 264                        void *tmp = out;
 265                        outsize = outsize * 3 / 2;
 266                        if (max_size && outsize >= max_size)
 267                                outsize = max_size + MAX_OP_SIZE + 1;
 268                        if (max_size && outpos > max_size)
 269                                out = NULL;
 270                        else
 271                                out = realloc(out, outsize);
 272                        if (!out) {
 273                                free(tmp);
 274                                free(hash);
 275                                return NULL;
 276                        }
 277                }
 278        }
 279
 280        if (inscnt)
 281                out[outpos - inscnt - 1] = inscnt;
 282
 283        free(hash);
 284        *delta_size = outpos;
 285        return out;
 286}