Toll Free Numbers
  • Last 5 Forum Topics
    Last post

The Web Only This Site



  • MARC

    Mailing list ARChives
    - Search by -


    Computing Dictionary

  • Text Link Ads
  • LINUX man pages
  • Linux Man Page Viewer

    The following form allows you to view linux man pages.





           git pack-objects [-q | --progress | --all-progress] [--all-progress-implied]
                   [--no-reuse-delta] [--delta-base-offset] [--non-empty]
                   [--local] [--incremental] [--window=N] [--depth=N]
                   [--revs [--unpacked | --all]*] [--stdout | base-name]
                   [--keep-true-parents] < object-list


           Reads list of objects from the standard input, and writes a packed
           archive with specified base-name, or to the standard output.
           A packed archive is an efficient way to transfer a set of objects
           between two repositories as well as an access efficient archival
           format. In a packed archive, an object is either stored as a compressed
           whole or as a difference from some other object. The latter is often
           called a delta.
           The packed archive format (.pack) is designed to be self-contained so
           that it can be unpacked without any further information. Therefore,
           each object that a delta depends upon must be present within the pack.
           A pack index file (.idx) is generated for fast, random access to the
           objects in the pack. Placing both the index file (.idx) and the packed
           archive (.pack) in the pack/ subdirectory of $GIT_OBJECT_DIRECTORY (or
           any of the directories on $GIT_ALTERNATE_OBJECT_DIRECTORIES) enables
           git to read from the pack archive.
           The git unpack-objects command can read the packed archive and expand
           the objects contained in the pack into "one-file one-object" format;
           this is typically done by the smart-pull commands when a pack is
           created on-the-fly for efficient network transport by their peers.


               Write into a pair of files (.pack and .idx), using <base-name> to
               determine the name of the created file. When this option is used,
               the two files are written in <base-name>-<SHA1>.{pack,idx} files.
               <SHA1> is a hash of the sorted object names to make the resulting
               filename based on the pack content, and written to the standard
               output of the command.
               Write the pack contents (what would have been written to .pack
               file) out to the standard output.
               Read the revision arguments from the standard input, instead of
               individual object names. The revision arguments are processed the
               same way as git rev-list with the --objects flag uses its commit
               arguments to build the list of objects it outputs. The objects on
               the resulting list are packed.
               tags to native git clients.
           --window=[N], --depth=[N]
               These two options affect how the objects contained in the pack are
               stored using delta compression. The objects are first internally
               sorted by type, size and optionally names and compared against the
               other objects within --window to see if using delta compression
               saves space. --depth limits the maximum delta depth; making it too
               deep affects the performance on the unpacker side, because delta
               data needs to be applied that many times to get to the necessary
               object. The default value for --window is 10 and --depth is 50.
               This option provides an additional limit on top of --window; the
               window size will dynamically scale down so as to not take up more
               than N bytes in memory. This is useful in repositories with a mix
               of large and small objects to not run out of memory with a large
               window, but still be able to take advantage of the large window for
               the smaller objects. The size can be suffixed with "k", "m", or
               "g".  --window-memory=0 makes memory usage unlimited, which is the
               Maximum size of each output pack file. The size can be suffixed
               with "k", "m", or "g". The minimum size allowed is limited to 1
               MiB. If specified, multiple packfiles may be created. The default
               is unlimited, unless the config variable pack.packSizeLimit is set.
               This flag causes an object already in a local pack that has a .keep
               file to be ignored, even if it it would have otherwise been packed.
               This flag causes an object already in a pack to be ignored even if
               it would have otherwise been packed.
               This flag causes an object that is borrowed from an alternate
               object store to be ignored even if it would have otherwise been
               Only create a packed archive if it would contain at least one
               Progress status is reported on the standard error stream by default
               when it is attached to a terminal, unless -q is specified. This
               flag forces progress status even if the standard error stream is
               not directed to a terminal.
               This flag makes the command not to report its progress on the
               standard error stream.
               When creating a packed archive in a repository that has existing
               packs, the command reuses existing deltas. This sometimes results
               in a slightly suboptimal pack. This flag tells the command not to
               reuse existing deltas but compute them from scratch.
               This flag tells the command not to reuse existing object data at
               all, including non deltified object, forcing recompression of
               everything. This implies --no-reuse-delta. Useful only in the
               obscure case where wholesale enforcement of a different compression
               level on the packed data is desired.
               Specifies compression level for newly-compressed data in the
               generated pack. If not specified, pack compression level is
               determined first by pack.compression, then by core.compression, and
               defaults to -1, the zlib default, if neither is set. Add
               --no-reuse-object if you want to force a uniform compression level
               on all data no matter the source.
               Create a "thin" pack by omitting the common objects between a
               sender and a receiver in order to reduce network transfer. This
               option only makes sense in conjunction with --stdout.
               Note: A thin pack violates the packed archive format by omitting
               required objects and is thus unusable by git without making it
               self-contained. Use git index-pack --fix-thin (see git-index-
               pack(1)) to restore the self-contained property.
               A packed archive can express base object of a delta as either
               20-byte object name or as an offset in the stream, but older
               version of git does not understand the latter. By default, git
               pack-objects only uses the former format for better compatibility.
               This option allows the command to use the latter format for
               compactness. Depending on the average delta chain length, this
               option typically shrinks the resulting packfile by 3-5 per-cent.
               Specifies the number of threads to spawn when searching for best
               delta matches. This requires that pack-objects be compiled with
               pthreads otherwise this option is ignored with a warning. This is
               meant to reduce packing time on multiprocessor machines. The
               required amount of memory for the delta search window is however
               multiplied by the number of threads. Specifying 0 will cause git to
               auto-detect the number of CPU's and set the number of threads
           Documentation by Junio C Hamano


           git-rev-list(1) git-repack(1) git-prune-packed(1)


           Part of the git(1) suite



    Git 1.7.1 03/04/2013 GIT-PACK-OBJECTS(1)


  • Linux

    The Distributions


    The Software


    The News


  • Toll Free

Toll Free Numbers
Copyright © 1999 - 2016 by LinuxGuruz