Merge branch 'sp/maint-index-pack'
authorJunio C Hamano <gitster@pobox.com>
Thu, 17 Jul 2008 00:11:18 +0000 (17:11 -0700)
committerJunio C Hamano <gitster@pobox.com>
Thu, 17 Jul 2008 00:11:18 +0000 (17:11 -0700)
* sp/maint-index-pack:
index-pack: Honor core.deltaBaseCacheLimit when resolving deltas
index-pack: Track the object_entry that creates each base_data
index-pack: Chain the struct base_data on the stack for traversal
index-pack: Refactor base arguments of resolve_delta into a struct

1  2 
index-pack.c
diff --combined index-pack.c
index 25db5db24b239409657510e8c2eeb3845b374bbf,c359f8c9dfda90344277a0c4f0cc8098d6936f3e..b4ec7361748640c7ced04c10e9087e12c553d928
@@@ -26,6 -26,14 +26,14 @@@ union delta_base 
        off_t offset;
  };
  
+ struct base_data {
+       struct base_data *base;
+       struct base_data *child;
+       struct object_entry *obj;
+       void *data;
+       unsigned long size;
+ };
  /*
   * Even if sizeof(union delta_base) == 24 on 64-bit archs, we really want
   * to memcmp() only the first 20 bytes.
@@@ -43,6 -51,8 +51,8 @@@ struct delta_entr
  
  static struct object_entry *objects;
  static struct delta_entry *deltas;
+ static struct base_data *base_cache;
+ static size_t base_cache_used;
  static int nr_objects;
  static int nr_deltas;
  static int nr_resolved_deltas;
@@@ -190,8 -200,7 +200,8 @@@ static void parse_pack_header(void
        if (hdr->hdr_signature != htonl(PACK_SIGNATURE))
                die("pack signature mismatch");
        if (!pack_version_ok(hdr->hdr_version))
 -              die("pack version %d unsupported", ntohl(hdr->hdr_version));
 +              die("pack version %"PRIu32" unsupported",
 +                      ntohl(hdr->hdr_version));
  
        nr_objects = ntohl(hdr->hdr_entries);
        use(sizeof(struct pack_header));
@@@ -211,6 -220,46 +221,46 @@@ static void bad_object(unsigned long of
        die("pack has bad object at offset %lu: %s", offset, buf);
  }
  
+ static void prune_base_data(struct base_data *retain)
+ {
+       struct base_data *b = base_cache;
+       for (b = base_cache;
+            base_cache_used > delta_base_cache_limit && b;
+            b = b->child) {
+               if (b->data && b != retain) {
+                       free(b->data);
+                       b->data = NULL;
+                       base_cache_used -= b->size;
+               }
+       }
+ }
+ static void link_base_data(struct base_data *base, struct base_data *c)
+ {
+       if (base)
+               base->child = c;
+       else
+               base_cache = c;
+       c->base = base;
+       c->child = NULL;
+       base_cache_used += c->size;
+       prune_base_data(c);
+ }
+ static void unlink_base_data(struct base_data *c)
+ {
+       struct base_data *base = c->base;
+       if (base)
+               base->child = NULL;
+       else
+               base_cache = NULL;
+       if (c->data) {
+               free(c->data);
+               base_cache_used -= c->size;
+       }
+ }
  static void *unpack_entry_data(unsigned long offset, unsigned long size)
  {
        z_stream stream;
@@@ -426,33 -475,60 +476,60 @@@ static void sha1_object(const void *dat
        }
  }
  
- static void resolve_delta(struct object_entry *delta_obj, void *base_data,
-                         unsigned long base_size, enum object_type type)
+ static void *get_base_data(struct base_data *c)
+ {
+       if (!c->data) {
+               struct object_entry *obj = c->obj;
+               if (obj->type == OBJ_REF_DELTA || obj->type == OBJ_OFS_DELTA) {
+                       void *base = get_base_data(c->base);
+                       void *raw = get_data_from_pack(obj);
+                       c->data = patch_delta(
+                               base, c->base->size,
+                               raw, obj->size,
+                               &c->size);
+                       free(raw);
+                       if (!c->data)
+                               bad_object(obj->idx.offset, "failed to apply delta");
+               } else
+                       c->data = get_data_from_pack(obj);
+               base_cache_used += c->size;
+               prune_base_data(c);
+       }
+       return c->data;
+ }
+ static void resolve_delta(struct object_entry *delta_obj,
+                         struct base_data *base_obj, enum object_type type)
  {
        void *delta_data;
        unsigned long delta_size;
-       void *result;
-       unsigned long result_size;
        union delta_base delta_base;
        int j, first, last;
+       struct base_data result;
  
        delta_obj->real_type = type;
        delta_data = get_data_from_pack(delta_obj);
        delta_size = delta_obj->size;
-       result = patch_delta(base_data, base_size, delta_data, delta_size,
-                            &result_size);
+       result.data = patch_delta(get_base_data(base_obj), base_obj->size,
+                            delta_data, delta_size,
+                            &result.size);
        free(delta_data);
-       if (!result)
+       if (!result.data)
                bad_object(delta_obj->idx.offset, "failed to apply delta");
-       sha1_object(result, result_size, type, delta_obj->idx.sha1);
+       sha1_object(result.data, result.size, type, delta_obj->idx.sha1);
        nr_resolved_deltas++;
  
+       result.obj = delta_obj;
+       link_base_data(base_obj, &result);
        hashcpy(delta_base.sha1, delta_obj->idx.sha1);
        if (!find_delta_children(&delta_base, &first, &last)) {
                for (j = first; j <= last; j++) {
                        struct object_entry *child = objects + deltas[j].obj_no;
                        if (child->real_type == OBJ_REF_DELTA)
-                               resolve_delta(child, result, result_size, type);
+                               resolve_delta(child, &result, type);
                }
        }
  
                for (j = first; j <= last; j++) {
                        struct object_entry *child = objects + deltas[j].obj_no;
                        if (child->real_type == OBJ_OFS_DELTA)
-                               resolve_delta(child, result, result_size, type);
+                               resolve_delta(child, &result, type);
                }
        }
  
-       free(result);
+       unlink_base_data(&result);
  }
  
  static int compare_delta_entry(const void *a, const void *b)
@@@ -481,7 -557,6 +558,6 @@@ static void parse_pack_objects(unsigne
  {
        int i;
        struct delta_entry *delta = deltas;
-       void *data;
        struct stat st;
  
        /*
                                nr_objects);
        for (i = 0; i < nr_objects; i++) {
                struct object_entry *obj = &objects[i];
-               data = unpack_raw_entry(obj, &delta->base);
+               void *data = unpack_raw_entry(obj, &delta->base);
                obj->real_type = obj->type;
                if (obj->type == OBJ_REF_DELTA || obj->type == OBJ_OFS_DELTA) {
                        nr_deltas++;
                struct object_entry *obj = &objects[i];
                union delta_base base;
                int j, ref, ref_first, ref_last, ofs, ofs_first, ofs_last;
+               struct base_data base_obj;
  
                if (obj->type == OBJ_REF_DELTA || obj->type == OBJ_OFS_DELTA)
                        continue;
                ofs = !find_delta_children(&base, &ofs_first, &ofs_last);
                if (!ref && !ofs)
                        continue;
-               data = get_data_from_pack(obj);
+               base_obj.data = get_data_from_pack(obj);
+               base_obj.size = obj->size;
+               base_obj.obj = obj;
+               link_base_data(NULL, &base_obj);
                if (ref)
                        for (j = ref_first; j <= ref_last; j++) {
                                struct object_entry *child = objects + deltas[j].obj_no;
                                if (child->real_type == OBJ_REF_DELTA)
-                                       resolve_delta(child, data,
-                                                     obj->size, obj->type);
+                                       resolve_delta(child, &base_obj, obj->type);
                        }
                if (ofs)
                        for (j = ofs_first; j <= ofs_last; j++) {
                                struct object_entry *child = objects + deltas[j].obj_no;
                                if (child->real_type == OBJ_OFS_DELTA)
-                                       resolve_delta(child, data,
-                                                     obj->size, obj->type);
+                                       resolve_delta(child, &base_obj, obj->type);
                        }
-               free(data);
+               unlink_base_data(&base_obj);
                display_progress(progress, nr_resolved_deltas);
        }
  }
@@@ -601,7 -679,8 +680,8 @@@ static int write_compressed(int fd, voi
        return size;
  }
  
- static void append_obj_to_pack(const unsigned char *sha1, void *buf,
+ static struct object_entry *append_obj_to_pack(
+                              const unsigned char *sha1, void *buf,
                               unsigned long size, enum object_type type)
  {
        struct object_entry *obj = &objects[nr_objects++];
        obj[1].idx.offset = obj[0].idx.offset + n;
        obj[1].idx.offset += write_compressed(output_fd, buf, size, &obj[0].idx.crc32);
        hashcpy(obj->idx.sha1, sha1);
+       return obj;
  }
  
  static int delta_pos_compare(const void *_a, const void *_b)
@@@ -656,28 -736,31 +737,31 @@@ static void fix_unresolved_deltas(int n
  
        for (i = 0; i < n; i++) {
                struct delta_entry *d = sorted_by_pos[i];
-               void *data;
-               unsigned long size;
                enum object_type type;
                int j, first, last;
+               struct base_data base_obj;
  
                if (objects[d->obj_no].real_type != OBJ_REF_DELTA)
                        continue;
-               data = read_sha1_file(d->base.sha1, &type, &size);
-               if (!data)
+               base_obj.data = read_sha1_file(d->base.sha1, &type, &base_obj.size);
+               if (!base_obj.data)
                        continue;
  
+               if (check_sha1_signature(d->base.sha1, base_obj.data,
+                               base_obj.size, typename(type)))
+                       die("local object %s is corrupt", sha1_to_hex(d->base.sha1));
+               base_obj.obj = append_obj_to_pack(d->base.sha1, base_obj.data,
+                       base_obj.size, type);
+               link_base_data(NULL, &base_obj);
                find_delta_children(&d->base, &first, &last);
                for (j = first; j <= last; j++) {
                        struct object_entry *child = objects + deltas[j].obj_no;
                        if (child->real_type == OBJ_REF_DELTA)
-                               resolve_delta(child, data, size, type);
+                               resolve_delta(child, &base_obj, type);
                }
  
-               if (check_sha1_signature(d->base.sha1, data, size, typename(type)))
-                       die("local object %s is corrupt", sha1_to_hex(d->base.sha1));
-               append_obj_to_pack(d->base.sha1, data, size, type);
-               free(data);
+               unlink_base_data(&base_obj);
                display_progress(progress, nr_resolved_deltas);
        }
        free(sorted_by_pos);
@@@ -772,8 -855,7 +856,8 @@@ static int git_index_pack_config(const 
        if (!strcmp(k, "pack.indexversion")) {
                pack_idx_default_version = git_config_int(k, v);
                if (pack_idx_default_version > 2)
 -                      die("bad pack.indexversion=%d", pack_idx_default_version);
 +                      die("bad pack.indexversion=%"PRIu32,
 +                              pack_idx_default_version);
                return 0;
        }
        return git_default_config(k, v, cb);