cocci: simplify "if (++u > 1)" to "if (u++)"

diff --git a/pack-objects.h b/pack-objects.h
index edf74dabddfdb2b67bad803d1c898e93a3af4d8b..62806ccc39ea31b425089f4f38121d81a02fe5dd 100644 (file)
--- a/pack-objects.h
+++ b/pack-objects.h
@@ -2,6 +2,8 @@
 #define PACK_OBJECTS_H
 
 #include "object-store.h"
+#include "thread-utils.h"
+#include "pack.h"
 
 #define DEFAULT_DELTA_CACHE_SIZE (256 * 1024 * 1024)
 
@@ -14,7 +16,7 @@
  * above this limit. Don't lower it too much.
  */
 #define OE_SIZE_BITS           31
-#define OE_DELTA_SIZE_BITS     20
+#define OE_DELTA_SIZE_BITS     23
 
 /*
  * State flags for depth-first search used for analyzing delta cycles.
@@ -94,11 +96,12 @@ struct object_entry {
                                     */
        unsigned delta_size_:OE_DELTA_SIZE_BITS; /* delta data size (uncompressed) */
        unsigned delta_size_valid:1;
+       unsigned char in_pack_header_size;
        unsigned in_pack_idx:OE_IN_PACK_BITS;   /* already in pack */
        unsigned z_delta_size:OE_Z_DELTA_BITS;
        unsigned type_valid:1;
-       unsigned type_:TYPE_BITS;
        unsigned no_try_delta:1;
+       unsigned type_:TYPE_BITS;
        unsigned in_pack_type:TYPE_BITS; /* could be delta */
        unsigned preferred_base:1; /*
                                    * we do not pack this, but is available
@@ -108,17 +111,16 @@ struct object_entry {
        unsigned tagged:1; /* near the very tip of refs */
        unsigned filled:1; /* assigned write-order */
        unsigned dfs_state:OE_DFS_STATE_BITS;
-       unsigned char in_pack_header_size;
        unsigned depth:OE_DEPTH_BITS;
 
        /*
         * pahole results on 64-bit linux (gcc and clang)
         *
-        *   size: 80, bit_padding: 20 bits, holes: 8 bits
+        *   size: 80, bit_padding: 9 bits
         *
         * and on 32-bit (gcc)
         *
-        *   size: 76, bit_padding: 20 bits, holes: 8 bits
+        *   size: 76, bit_padding: 9 bits
         */
 };
 
@@ -130,6 +132,7 @@ struct packing_data {
        uint32_t index_size;
 
        unsigned int *in_pack_pos;
+       unsigned long *delta_size;
 
        /*
         * Only one of these can be non-NULL and they have different
@@ -140,10 +143,29 @@ struct packing_data {
        struct packed_git **in_pack_by_idx;
        struct packed_git **in_pack;
 
+#ifndef NO_PTHREADS
+       pthread_mutex_t lock;
+#endif
+
        uintmax_t oe_size_limit;
+       uintmax_t oe_delta_size_limit;
 };
 
 void prepare_packing_data(struct packing_data *pdata);
+
+static inline void packing_data_lock(struct packing_data *pdata)
+{
+#ifndef NO_PTHREADS
+       pthread_mutex_lock(&pdata->lock);
+#endif
+}
+static inline void packing_data_unlock(struct packing_data *pdata)
+{
+#ifndef NO_PTHREADS
+       pthread_mutex_unlock(&pdata->lock);
+#endif
+}
+
 struct object_entry *packlist_alloc(struct packing_data *pdata,
                                    const unsigned char *sha1,
                                    uint32_t index_pos);
@@ -332,18 +354,34 @@ static inline unsigned long oe_delta_size(struct packing_data *pack,
 {
        if (e->delta_size_valid)
                return e->delta_size_;
-       return oe_size(pack, e);
+
+       /*
+        * pack->detla_size[] can't be NULL because oe_set_delta_size()
+        * must have been called when a new delta is saved with
+        * oe_set_delta().
+        * If oe_delta() returns NULL (i.e. default state, which means
+        * delta_size_valid is also false), then the caller must never
+        * call oe_delta_size().
+        */
+       return pack->delta_size[e - pack->objects];
 }
 
 static inline void oe_set_delta_size(struct packing_data *pack,
                                     struct object_entry *e,
                                     unsigned long size)
 {
-       e->delta_size_ = size;
-       e->delta_size_valid = e->delta_size_ == size;
-       if (!e->delta_size_valid && size != oe_size(pack, e))
-               BUG("this can only happen in check_object() "
-                   "where delta size is the same as entry size");
+       if (size < pack->oe_delta_size_limit) {
+               e->delta_size_ = size;
+               e->delta_size_valid = 1;
+       } else {
+               packing_data_lock(pack);
+               if (!pack->delta_size)
+                       ALLOC_ARRAY(pack->delta_size, pack->nr_alloc);
+               packing_data_unlock(pack);
+
+               pack->delta_size[e - pack->objects] = size;
+               e->delta_size_valid = 0;
+       }
 }
 
 #endif