pack-objects: shrink size field in struct object_entry

diff --git a/pack-objects.h b/pack-objects.h
index e962dce3c05be345bf0184d76d3ea3b7be190885..ee2c7ab382b64d56e9021c3a9022b7531e55724a 100644 (file)
--- a/pack-objects.h
+++ b/pack-objects.h
@@ -6,6 +6,12 @@
 #define OE_DFS_STATE_BITS      2
 #define OE_DEPTH_BITS          12
 #define OE_IN_PACK_BITS                10
+#define OE_Z_DELTA_BITS                20
+/*
+ * Note that oe_set_size() becomes expensive when the given size is
+ * above this limit. Don't lower it too much.
+ */
+#define OE_SIZE_BITS           31
 
 /*
  * State flags for depth-first search used for analyzing delta cycles.
@@ -31,7 +37,9 @@ enum dfs_state {
  *
  * "size" is the uncompressed object size. Compressed size of the raw
  * data for an object in a pack is not stored anywhere but is computed
- * and made available when reverse .idx is made.
+ * and made available when reverse .idx is made. Note that when a
+ * delta is reused, "size" is the uncompressed _delta_ size, not the
+ * canonical one after the delta has been applied.
  *
  * "hash" contains a path name hash which is used for sorting the
  * delta list and also during delta searching. Once prepare_pack()
@@ -67,7 +75,8 @@ enum dfs_state {
  */
 struct object_entry {
        struct pack_idx_entry idx;
-       unsigned long size;     /* uncompressed size */
+       unsigned size_:OE_SIZE_BITS;
+       unsigned size_valid:1;
        unsigned in_pack_idx:OE_IN_PACK_BITS;   /* already in pack */
        off_t in_pack_offset;
        uint32_t delta_idx;     /* delta base object */
@@ -77,7 +86,7 @@ struct object_entry {
                                     */
        void *delta_data;       /* cached delta (uncompressed) */
        unsigned long delta_size;       /* delta data size (uncompressed) */
-       unsigned long z_delta_size;     /* delta data size (compressed) */
+       unsigned z_delta_size:OE_Z_DELTA_BITS;
        unsigned type_:TYPE_BITS;
        unsigned in_pack_type:TYPE_BITS; /* could be delta */
        unsigned type_valid:1;
@@ -112,6 +121,8 @@ struct packing_data {
         */
        struct packed_git **in_pack_by_idx;
        struct packed_git **in_pack;
+
+       uintmax_t oe_size_limit;
 };
 
 void prepare_packing_data(struct packing_data *pdata);
@@ -251,4 +262,51 @@ static inline void oe_set_delta_sibling(struct packing_data *pack,
                e->delta_sibling_idx = 0;
 }
 
+unsigned long oe_get_size_slow(struct packing_data *pack,
+                              const struct object_entry *e);
+static inline unsigned long oe_size(struct packing_data *pack,
+                                   const struct object_entry *e)
+{
+       if (e->size_valid)
+               return e->size_;
+
+       return oe_get_size_slow(pack, e);
+}
+
+static inline int oe_size_less_than(struct packing_data *pack,
+                                   const struct object_entry *lhs,
+                                   unsigned long rhs)
+{
+       if (lhs->size_valid)
+               return lhs->size_ < rhs;
+       if (rhs < pack->oe_size_limit) /* rhs < 2^x <= lhs ? */
+               return 0;
+       return oe_get_size_slow(pack, lhs) < rhs;
+}
+
+static inline int oe_size_greater_than(struct packing_data *pack,
+                                      const struct object_entry *lhs,
+                                      unsigned long rhs)
+{
+       if (lhs->size_valid)
+               return lhs->size_ > rhs;
+       if (rhs < pack->oe_size_limit) /* rhs < 2^x <= lhs ? */
+               return 1;
+       return oe_get_size_slow(pack, lhs) > rhs;
+}
+
+static inline void oe_set_size(struct packing_data *pack,
+                              struct object_entry *e,
+                              unsigned long size)
+{
+       if (size < pack->oe_size_limit) {
+               e->size_ = size;
+               e->size_valid = 1;
+       } else {
+               e->size_valid = 0;
+               if (oe_get_size_slow(pack, e) != size)
+                       BUG("'size' is supposed to be the object size!");
+       }
+}
+
 #endif