Documentation/config/pack.txt

   1 pack.window::
   2         The size of the window used by linkgit:git-pack-objects[1] when no
   3         window size is given on the command line. Defaults to 10.
   4
   5 pack.depth::
   6         The maximum delta depth used by linkgit:git-pack-objects[1] when no
   7         maximum depth is given on the command line. Defaults to 50.
   8         Maximum value is 4095.
   9
  10 pack.windowMemory::
  11         The maximum size of memory that is consumed by each thread
  12         in linkgit:git-pack-objects[1] for pack window memory when
  13         no limit is given on the command line.  The value can be
  14         suffixed with "k", "m", or "g".  When left unconfigured (or
  15         set explicitly to 0), there will be no limit.
  16
  17 pack.compression::
  18         An integer -1..9, indicating the compression level for objects
  19         in a pack file. -1 is the zlib default. 0 means no
  20         compression, and 1..9 are various speed/size tradeoffs, 9 being
  21         slowest.  If not set,  defaults to core.compression.  If that is
  22         not set,  defaults to -1, the zlib default, which is "a default
  23         compromise between speed and compression (currently equivalent
  24         to level 6)."
  25 +
  26 Note that changing the compression level will not automatically recompress
  27 all existing objects. You can force recompression by passing the -F option
  28 to linkgit:git-repack[1].
  29
  30 pack.allowPackReuse::
  31         When true or "single", and when reachability bitmaps are
  32         enabled, pack-objects will try to send parts of the bitmapped
  33         packfile verbatim. When "multi", and when a multi-pack
  34         reachability bitmap is available, pack-objects will try to send
  35         parts of all packs in the MIDX.
  36 +
  37         If only a single pack bitmap is available, and
  38         `pack.allowPackReuse` is set to "multi", reuse parts of just the
  39         bitmapped packfile. This can reduce memory and CPU usage to
  40         serve fetches, but might result in sending a slightly larger
  41         pack. Defaults to true.
  42
  43 pack.island::
  44         An extended regular expression configuring a set of delta
  45         islands. See "DELTA ISLANDS" in linkgit:git-pack-objects[1]
  46         for details.
  47
  48 pack.islandCore::
  49         Specify an island name which gets to have its objects be
  50         packed first. This creates a kind of pseudo-pack at the front
  51         of one pack, so that the objects from the specified island are
  52         hopefully faster to copy into any pack that should be served
  53         to a user requesting these objects. In practice this means
  54         that the island specified should likely correspond to what is
  55         the most commonly cloned in the repo. See also "DELTA ISLANDS"
  56         in linkgit:git-pack-objects[1].
  57
  58 pack.deltaCacheSize::
  59         The maximum memory in bytes used for caching deltas in
  60         linkgit:git-pack-objects[1] before writing them out to a pack.
  61         This cache is used to speed up the writing object phase by not
  62         having to recompute the final delta result once the best match
  63         for all objects is found.  Repacking large repositories on machines
  64         which are tight with memory might be badly impacted by this though,
  65         especially if this cache pushes the system into swapping.
  66         A value of 0 means no limit. The smallest size of 1 byte may be
  67         used to virtually disable this cache. Defaults to 256 MiB.
  68
  69 pack.deltaCacheLimit::
  70         The maximum size of a delta, that is cached in
  71         linkgit:git-pack-objects[1]. This cache is used to speed up the
  72         writing object phase by not having to recompute the final delta
  73         result once the best match for all objects is found.
  74         Defaults to 1000. Maximum value is 65535.
  75
  76 pack.threads::
  77         Specifies the number of threads to spawn when searching for best
  78         delta matches.  This requires that linkgit:git-pack-objects[1]
  79         be compiled with pthreads otherwise this option is ignored with a
  80         warning. This is meant to reduce packing time on multiprocessor
  81         machines. The required amount of memory for the delta search window
  82         is however multiplied by the number of threads.
  83         Specifying 0 will cause Git to auto-detect the number of CPUs
  84         and set the number of threads accordingly.
  85
  86 pack.indexVersion::
  87         Specify the default pack index version.  Valid values are 1 for
  88         legacy pack index used by Git versions prior to 1.5.2, and 2 for
  89         the new pack index with capabilities for packs larger than 4 GB
  90         as well as proper protection against the repacking of corrupted
  91         packs.  Version 2 is the default.  Note that version 2 is enforced
  92         and this config option is ignored whenever the corresponding pack is
  93         larger than 2 GB.
  94 +
  95 If you have an old Git that does not understand the version 2 `*.idx` file,
  96 cloning or fetching over a non-native protocol (e.g. "http")
  97 that will copy both `*.pack` file and corresponding `*.idx` file from the
  98 other side may give you a repository that cannot be accessed with your
  99 older version of Git. If the `*.pack` file is smaller than 2 GB, however,
 100 you can use linkgit:git-index-pack[1] on the *.pack file to regenerate
 101 the `*.idx` file.
 102
 103 pack.packSizeLimit::
 104         The maximum size of a pack.  This setting only affects
 105         packing to a file when repacking, i.e. the git:// protocol
 106         is unaffected.  It can be overridden by the `--max-pack-size`
 107         option of linkgit:git-repack[1].  Reaching this limit results
 108         in the creation of multiple packfiles.
 109 +
 110 Note that this option is rarely useful, and may result in a larger total
 111 on-disk size (because Git will not store deltas between packs) and
 112 worse runtime performance (object lookup within multiple packs is
 113 slower than a single pack, and optimizations like reachability bitmaps
 114 cannot cope with multiple packs).
 115 +
 116 If you need to actively run Git using smaller packfiles (e.g., because your
 117 filesystem does not support large files), this option may help. But if
 118 your goal is to transmit a packfile over a medium that supports limited
 119 sizes (e.g., removable media that cannot store the whole repository),
 120 you are likely better off creating a single large packfile and splitting
 121 it using a generic multi-volume archive tool (e.g., Unix `split`).
 122 +
 123 The minimum size allowed is limited to 1 MiB. The default is unlimited.
 124 Common unit suffixes of 'k', 'm', or 'g' are supported.
 125
 126 pack.useBitmaps::
 127         When true, git will use pack bitmaps (if available) when packing
 128         to stdout (e.g., during the server side of a fetch). Defaults to
 129         true. You should not generally need to turn this off unless
 130         you are debugging pack bitmaps.
 131
 132 pack.useBitmapBoundaryTraversal::
 133         When true, Git will use an experimental algorithm for computing
 134         reachability queries with bitmaps. Instead of building up
 135         complete bitmaps for all of the negated tips and then OR-ing
 136         them together, consider negated tips with existing bitmaps as
 137         additive (i.e. OR-ing them into the result if they exist,
 138         ignoring them otherwise), and build up a bitmap at the boundary
 139         instead.
 140 +
 141 When using this algorithm, Git may include too many objects as a result
 142 of not opening up trees belonging to certain UNINTERESTING commits. This
 143 inexactness matches the non-bitmap traversal algorithm.
 144 +
 145 In many cases, this can provide a speed-up over the exact algorithm,
 146 particularly when there is poor bitmap coverage of the negated side of
 147 the query.
 148
 149 pack.useSparse::
 150         When true, git will default to using the '--sparse' option in
 151         'git pack-objects' when the '--revs' option is present. This
 152         algorithm only walks trees that appear in paths that introduce new
 153         objects. This can have significant performance benefits when
 154         computing a pack to send a small change. However, it is possible
 155         that extra objects are added to the pack-file if the included
 156         commits contain certain types of direct renames. Default is
 157         `true`.
 158
 159 pack.preferBitmapTips::
 160         When selecting which commits will receive bitmaps, prefer a
 161         commit at the tip of any reference that is a suffix of any value
 162         of this configuration over any other commits in the "selection
 163         window".
 164 +
 165 Note that setting this configuration to `refs/foo` does not mean that
 166 the commits at the tips of `refs/foo/bar` and `refs/foo/baz` will
 167 necessarily be selected. This is because commits are selected for
 168 bitmaps from within a series of windows of variable length.
 169 +
 170 If a commit at the tip of any reference which is a suffix of any value
 171 of this configuration is seen in a window, it is immediately given
 172 preference over any other commit in that window.
 173
 174 pack.writeBitmaps (deprecated)::
 175         This is a deprecated synonym for `repack.writeBitmaps`.
 176
 177 pack.writeBitmapHashCache::
 178         When true, git will include a "hash cache" section in the bitmap
 179         index (if one is written). This cache can be used to feed git's
 180         delta heuristics, potentially leading to better deltas between
 181         bitmapped and non-bitmapped objects (e.g., when serving a fetch
 182         between an older, bitmapped pack and objects that have been
 183         pushed since the last gc). The downside is that it consumes 4
 184         bytes per object of disk space. Defaults to true.
 185 +
 186 When writing a multi-pack reachability bitmap, no new namehashes are
 187 computed; instead, any namehashes stored in an existing bitmap are
 188 permuted into their appropriate location when writing a new bitmap.
 189
 190 pack.writeBitmapLookupTable::
 191         When true, Git will include a "lookup table" section in the
 192         bitmap index (if one is written). This table is used to defer
 193         loading individual bitmaps as late as possible. This can be
 194         beneficial in repositories that have relatively large bitmap
 195         indexes. Defaults to false.
 196
 197 pack.readReverseIndex::
 198         When true, git will read any .rev file(s) that may be available
 199         (see: linkgit:gitformat-pack[5]). When false, the reverse index
 200         will be generated from scratch and stored in memory. Defaults to
 201         true.
 202
 203 pack.writeReverseIndex::
 204         When true, git will write a corresponding .rev file (see:
 205         linkgit:gitformat-pack[5])
 206         for each new packfile that it writes in all places except for
 207         linkgit:git-fast-import[1] and in the bulk checkin mechanism.
 208         Defaults to true.