1450 lines
45 KiB
HTML
1450 lines
45 KiB
HTML
<?xml version="1.0" encoding="UTF-8"?>
|
|
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
|
|
"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
|
|
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en">
|
|
<head>
|
|
<meta http-equiv="Content-Type" content="application/xhtml+xml; charset=UTF-8" />
|
|
<meta name="generator" content="AsciiDoc 10.2.0" />
|
|
<title>git-pack-objects(1)</title>
|
|
<style type="text/css">
|
|
/* Shared CSS for AsciiDoc xhtml11 and html5 backends */
|
|
|
|
/* Default font. */
|
|
body {
|
|
font-family: Georgia,serif;
|
|
}
|
|
|
|
/* Title font. */
|
|
h1, h2, h3, h4, h5, h6,
|
|
div.title, caption.title,
|
|
thead, p.table.header,
|
|
#toctitle,
|
|
#author, #revnumber, #revdate, #revremark,
|
|
#footer {
|
|
font-family: Arial,Helvetica,sans-serif;
|
|
}
|
|
|
|
body {
|
|
margin: 1em 5% 1em 5%;
|
|
}
|
|
|
|
a {
|
|
color: blue;
|
|
text-decoration: underline;
|
|
}
|
|
a:visited {
|
|
color: fuchsia;
|
|
}
|
|
|
|
em {
|
|
font-style: italic;
|
|
color: navy;
|
|
}
|
|
|
|
strong {
|
|
font-weight: bold;
|
|
color: #083194;
|
|
}
|
|
|
|
h1, h2, h3, h4, h5, h6 {
|
|
color: #527bbd;
|
|
margin-top: 1.2em;
|
|
margin-bottom: 0.5em;
|
|
line-height: 1.3;
|
|
}
|
|
|
|
h1, h2, h3 {
|
|
border-bottom: 2px solid silver;
|
|
}
|
|
h2 {
|
|
padding-top: 0.5em;
|
|
}
|
|
h3 {
|
|
float: left;
|
|
}
|
|
h3 + * {
|
|
clear: left;
|
|
}
|
|
h5 {
|
|
font-size: 1.0em;
|
|
}
|
|
|
|
div.sectionbody {
|
|
margin-left: 0;
|
|
}
|
|
|
|
hr {
|
|
border: 1px solid silver;
|
|
}
|
|
|
|
p {
|
|
margin-top: 0.5em;
|
|
margin-bottom: 0.5em;
|
|
}
|
|
|
|
ul, ol, li > p {
|
|
margin-top: 0;
|
|
}
|
|
ul > li { color: #aaa; }
|
|
ul > li > * { color: black; }
|
|
|
|
.monospaced, code, pre {
|
|
font-family: "Courier New", Courier, monospace;
|
|
font-size: inherit;
|
|
color: navy;
|
|
padding: 0;
|
|
margin: 0;
|
|
}
|
|
pre {
|
|
white-space: pre-wrap;
|
|
}
|
|
|
|
#author {
|
|
color: #527bbd;
|
|
font-weight: bold;
|
|
font-size: 1.1em;
|
|
}
|
|
#email {
|
|
}
|
|
#revnumber, #revdate, #revremark {
|
|
}
|
|
|
|
#footer {
|
|
font-size: small;
|
|
border-top: 2px solid silver;
|
|
padding-top: 0.5em;
|
|
margin-top: 4.0em;
|
|
}
|
|
#footer-text {
|
|
float: left;
|
|
padding-bottom: 0.5em;
|
|
}
|
|
#footer-badges {
|
|
float: right;
|
|
padding-bottom: 0.5em;
|
|
}
|
|
|
|
#preamble {
|
|
margin-top: 1.5em;
|
|
margin-bottom: 1.5em;
|
|
}
|
|
div.imageblock, div.exampleblock, div.verseblock,
|
|
div.quoteblock, div.literalblock, div.listingblock, div.sidebarblock,
|
|
div.admonitionblock {
|
|
margin-top: 1.0em;
|
|
margin-bottom: 1.5em;
|
|
}
|
|
div.admonitionblock {
|
|
margin-top: 2.0em;
|
|
margin-bottom: 2.0em;
|
|
margin-right: 10%;
|
|
color: #606060;
|
|
}
|
|
|
|
div.content { /* Block element content. */
|
|
padding: 0;
|
|
}
|
|
|
|
/* Block element titles. */
|
|
div.title, caption.title {
|
|
color: #527bbd;
|
|
font-weight: bold;
|
|
text-align: left;
|
|
margin-top: 1.0em;
|
|
margin-bottom: 0.5em;
|
|
}
|
|
div.title + * {
|
|
margin-top: 0;
|
|
}
|
|
|
|
td div.title:first-child {
|
|
margin-top: 0.0em;
|
|
}
|
|
div.content div.title:first-child {
|
|
margin-top: 0.0em;
|
|
}
|
|
div.content + div.title {
|
|
margin-top: 0.0em;
|
|
}
|
|
|
|
div.sidebarblock > div.content {
|
|
background: #ffffee;
|
|
border: 1px solid #dddddd;
|
|
border-left: 4px solid #f0f0f0;
|
|
padding: 0.5em;
|
|
}
|
|
|
|
div.listingblock > div.content {
|
|
border: 1px solid #dddddd;
|
|
border-left: 5px solid #f0f0f0;
|
|
background: #f8f8f8;
|
|
padding: 0.5em;
|
|
}
|
|
|
|
div.quoteblock, div.verseblock {
|
|
padding-left: 1.0em;
|
|
margin-left: 1.0em;
|
|
margin-right: 10%;
|
|
border-left: 5px solid #f0f0f0;
|
|
color: #888;
|
|
}
|
|
|
|
div.quoteblock > div.attribution {
|
|
padding-top: 0.5em;
|
|
text-align: right;
|
|
}
|
|
|
|
div.verseblock > pre.content {
|
|
font-family: inherit;
|
|
font-size: inherit;
|
|
}
|
|
div.verseblock > div.attribution {
|
|
padding-top: 0.75em;
|
|
text-align: left;
|
|
}
|
|
/* DEPRECATED: Pre version 8.2.7 verse style literal block. */
|
|
div.verseblock + div.attribution {
|
|
text-align: left;
|
|
}
|
|
|
|
div.admonitionblock .icon {
|
|
vertical-align: top;
|
|
font-size: 1.1em;
|
|
font-weight: bold;
|
|
text-decoration: underline;
|
|
color: #527bbd;
|
|
padding-right: 0.5em;
|
|
}
|
|
div.admonitionblock td.content {
|
|
padding-left: 0.5em;
|
|
border-left: 3px solid #dddddd;
|
|
}
|
|
|
|
div.exampleblock > div.content {
|
|
border-left: 3px solid #dddddd;
|
|
padding-left: 0.5em;
|
|
}
|
|
|
|
div.imageblock div.content { padding-left: 0; }
|
|
span.image img { border-style: none; vertical-align: text-bottom; }
|
|
a.image:visited { color: white; }
|
|
|
|
dl {
|
|
margin-top: 0.8em;
|
|
margin-bottom: 0.8em;
|
|
}
|
|
dt {
|
|
margin-top: 0.5em;
|
|
margin-bottom: 0;
|
|
font-style: normal;
|
|
color: navy;
|
|
}
|
|
dd > *:first-child {
|
|
margin-top: 0.1em;
|
|
}
|
|
|
|
ul, ol {
|
|
list-style-position: outside;
|
|
}
|
|
ol.arabic {
|
|
list-style-type: decimal;
|
|
}
|
|
ol.loweralpha {
|
|
list-style-type: lower-alpha;
|
|
}
|
|
ol.upperalpha {
|
|
list-style-type: upper-alpha;
|
|
}
|
|
ol.lowerroman {
|
|
list-style-type: lower-roman;
|
|
}
|
|
ol.upperroman {
|
|
list-style-type: upper-roman;
|
|
}
|
|
|
|
div.compact ul, div.compact ol,
|
|
div.compact p, div.compact p,
|
|
div.compact div, div.compact div {
|
|
margin-top: 0.1em;
|
|
margin-bottom: 0.1em;
|
|
}
|
|
|
|
tfoot {
|
|
font-weight: bold;
|
|
}
|
|
td > div.verse {
|
|
white-space: pre;
|
|
}
|
|
|
|
div.hdlist {
|
|
margin-top: 0.8em;
|
|
margin-bottom: 0.8em;
|
|
}
|
|
div.hdlist tr {
|
|
padding-bottom: 15px;
|
|
}
|
|
dt.hdlist1.strong, td.hdlist1.strong {
|
|
font-weight: bold;
|
|
}
|
|
td.hdlist1 {
|
|
vertical-align: top;
|
|
font-style: normal;
|
|
padding-right: 0.8em;
|
|
color: navy;
|
|
}
|
|
td.hdlist2 {
|
|
vertical-align: top;
|
|
}
|
|
div.hdlist.compact tr {
|
|
margin: 0;
|
|
padding-bottom: 0;
|
|
}
|
|
|
|
.comment {
|
|
background: yellow;
|
|
}
|
|
|
|
.footnote, .footnoteref {
|
|
font-size: 0.8em;
|
|
}
|
|
|
|
span.footnote, span.footnoteref {
|
|
vertical-align: super;
|
|
}
|
|
|
|
#footnotes {
|
|
margin: 20px 0 20px 0;
|
|
padding: 7px 0 0 0;
|
|
}
|
|
|
|
#footnotes div.footnote {
|
|
margin: 0 0 5px 0;
|
|
}
|
|
|
|
#footnotes hr {
|
|
border: none;
|
|
border-top: 1px solid silver;
|
|
height: 1px;
|
|
text-align: left;
|
|
margin-left: 0;
|
|
width: 20%;
|
|
min-width: 100px;
|
|
}
|
|
|
|
div.colist td {
|
|
padding-right: 0.5em;
|
|
padding-bottom: 0.3em;
|
|
vertical-align: top;
|
|
}
|
|
div.colist td img {
|
|
margin-top: 0.3em;
|
|
}
|
|
|
|
@media print {
|
|
#footer-badges { display: none; }
|
|
}
|
|
|
|
#toc {
|
|
margin-bottom: 2.5em;
|
|
}
|
|
|
|
#toctitle {
|
|
color: #527bbd;
|
|
font-size: 1.1em;
|
|
font-weight: bold;
|
|
margin-top: 1.0em;
|
|
margin-bottom: 0.1em;
|
|
}
|
|
|
|
div.toclevel0, div.toclevel1, div.toclevel2, div.toclevel3, div.toclevel4 {
|
|
margin-top: 0;
|
|
margin-bottom: 0;
|
|
}
|
|
div.toclevel2 {
|
|
margin-left: 2em;
|
|
font-size: 0.9em;
|
|
}
|
|
div.toclevel3 {
|
|
margin-left: 4em;
|
|
font-size: 0.9em;
|
|
}
|
|
div.toclevel4 {
|
|
margin-left: 6em;
|
|
font-size: 0.9em;
|
|
}
|
|
|
|
span.aqua { color: aqua; }
|
|
span.black { color: black; }
|
|
span.blue { color: blue; }
|
|
span.fuchsia { color: fuchsia; }
|
|
span.gray { color: gray; }
|
|
span.green { color: green; }
|
|
span.lime { color: lime; }
|
|
span.maroon { color: maroon; }
|
|
span.navy { color: navy; }
|
|
span.olive { color: olive; }
|
|
span.purple { color: purple; }
|
|
span.red { color: red; }
|
|
span.silver { color: silver; }
|
|
span.teal { color: teal; }
|
|
span.white { color: white; }
|
|
span.yellow { color: yellow; }
|
|
|
|
span.aqua-background { background: aqua; }
|
|
span.black-background { background: black; }
|
|
span.blue-background { background: blue; }
|
|
span.fuchsia-background { background: fuchsia; }
|
|
span.gray-background { background: gray; }
|
|
span.green-background { background: green; }
|
|
span.lime-background { background: lime; }
|
|
span.maroon-background { background: maroon; }
|
|
span.navy-background { background: navy; }
|
|
span.olive-background { background: olive; }
|
|
span.purple-background { background: purple; }
|
|
span.red-background { background: red; }
|
|
span.silver-background { background: silver; }
|
|
span.teal-background { background: teal; }
|
|
span.white-background { background: white; }
|
|
span.yellow-background { background: yellow; }
|
|
|
|
span.big { font-size: 2em; }
|
|
span.small { font-size: 0.6em; }
|
|
|
|
span.underline { text-decoration: underline; }
|
|
span.overline { text-decoration: overline; }
|
|
span.line-through { text-decoration: line-through; }
|
|
|
|
div.unbreakable { page-break-inside: avoid; }
|
|
|
|
|
|
/*
|
|
* xhtml11 specific
|
|
*
|
|
* */
|
|
|
|
div.tableblock {
|
|
margin-top: 1.0em;
|
|
margin-bottom: 1.5em;
|
|
}
|
|
div.tableblock > table {
|
|
border: 3px solid #527bbd;
|
|
}
|
|
thead, p.table.header {
|
|
font-weight: bold;
|
|
color: #527bbd;
|
|
}
|
|
p.table {
|
|
margin-top: 0;
|
|
}
|
|
/* Because the table frame attribute is overridden by CSS in most browsers. */
|
|
div.tableblock > table[frame="void"] {
|
|
border-style: none;
|
|
}
|
|
div.tableblock > table[frame="hsides"] {
|
|
border-left-style: none;
|
|
border-right-style: none;
|
|
}
|
|
div.tableblock > table[frame="vsides"] {
|
|
border-top-style: none;
|
|
border-bottom-style: none;
|
|
}
|
|
|
|
|
|
/*
|
|
* html5 specific
|
|
*
|
|
* */
|
|
|
|
table.tableblock {
|
|
margin-top: 1.0em;
|
|
margin-bottom: 1.5em;
|
|
}
|
|
thead, p.tableblock.header {
|
|
font-weight: bold;
|
|
color: #527bbd;
|
|
}
|
|
p.tableblock {
|
|
margin-top: 0;
|
|
}
|
|
table.tableblock {
|
|
border-width: 3px;
|
|
border-spacing: 0px;
|
|
border-style: solid;
|
|
border-color: #527bbd;
|
|
border-collapse: collapse;
|
|
}
|
|
th.tableblock, td.tableblock {
|
|
border-width: 1px;
|
|
padding: 4px;
|
|
border-style: solid;
|
|
border-color: #527bbd;
|
|
}
|
|
|
|
table.tableblock.frame-topbot {
|
|
border-left-style: hidden;
|
|
border-right-style: hidden;
|
|
}
|
|
table.tableblock.frame-sides {
|
|
border-top-style: hidden;
|
|
border-bottom-style: hidden;
|
|
}
|
|
table.tableblock.frame-none {
|
|
border-style: hidden;
|
|
}
|
|
|
|
th.tableblock.halign-left, td.tableblock.halign-left {
|
|
text-align: left;
|
|
}
|
|
th.tableblock.halign-center, td.tableblock.halign-center {
|
|
text-align: center;
|
|
}
|
|
th.tableblock.halign-right, td.tableblock.halign-right {
|
|
text-align: right;
|
|
}
|
|
|
|
th.tableblock.valign-top, td.tableblock.valign-top {
|
|
vertical-align: top;
|
|
}
|
|
th.tableblock.valign-middle, td.tableblock.valign-middle {
|
|
vertical-align: middle;
|
|
}
|
|
th.tableblock.valign-bottom, td.tableblock.valign-bottom {
|
|
vertical-align: bottom;
|
|
}
|
|
|
|
|
|
/*
|
|
* manpage specific
|
|
*
|
|
* */
|
|
|
|
body.manpage h1 {
|
|
padding-top: 0.5em;
|
|
padding-bottom: 0.5em;
|
|
border-top: 2px solid silver;
|
|
border-bottom: 2px solid silver;
|
|
}
|
|
body.manpage h2 {
|
|
border-style: none;
|
|
}
|
|
body.manpage div.sectionbody {
|
|
margin-left: 3em;
|
|
}
|
|
|
|
@media print {
|
|
body.manpage div#toc { display: none; }
|
|
}
|
|
|
|
|
|
</style>
|
|
<script type="text/javascript">
|
|
/*<+'])');
|
|
// Function that scans the DOM tree for header elements (the DOM2
|
|
// nodeIterator API would be a better technique but not supported by all
|
|
// browsers).
|
|
var iterate = function (el) {
|
|
for (var i = el.firstChild; i != null; i = i.nextSibling) {
|
|
if (i.nodeType == 1 /* Node.ELEMENT_NODE */) {
|
|
var mo = re.exec(i.tagName);
|
|
if (mo && (i.getAttribute("class") || i.getAttribute("className")) != "float") {
|
|
result[result.length] = new TocEntry(i, getText(i), mo[1]-1);
|
|
}
|
|
iterate(i);
|
|
}
|
|
}
|
|
}
|
|
iterate(el);
|
|
return result;
|
|
}
|
|
|
|
var toc = document.getElementById("toc");
|
|
if (!toc) {
|
|
return;
|
|
}
|
|
|
|
// Delete existing TOC entries in case we're reloading the TOC.
|
|
var tocEntriesToRemove = [];
|
|
var i;
|
|
for (i = 0; i < toc.childNodes.length; i++) {
|
|
var entry = toc.childNodes[i];
|
|
if (entry.nodeName.toLowerCase() == 'div'
|
|
&& entry.getAttribute("class")
|
|
&& entry.getAttribute("class").match(/^toclevel/))
|
|
tocEntriesToRemove.push(entry);
|
|
}
|
|
for (i = 0; i < tocEntriesToRemove.length; i++) {
|
|
toc.removeChild(tocEntriesToRemove[i]);
|
|
}
|
|
|
|
// Rebuild TOC entries.
|
|
var entries = tocEntries(document.getElementById("content"), toclevels);
|
|
for (var i = 0; i < entries.length; ++i) {
|
|
var entry = entries[i];
|
|
if (entry.element.id == "")
|
|
entry.element.id = "_toc_" + i;
|
|
var a = document.createElement("a");
|
|
a.href = "#" + entry.element.id;
|
|
a.appendChild(document.createTextNode(entry.text));
|
|
var div = document.createElement("div");
|
|
div.appendChild(a);
|
|
div.className = "toclevel" + entry.toclevel;
|
|
toc.appendChild(div);
|
|
}
|
|
if (entries.length == 0)
|
|
toc.parentNode.removeChild(toc);
|
|
},
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
// Footnotes generator
|
|
/////////////////////////////////////////////////////////////////////
|
|
|
|
/* Based on footnote generation code from:
|
|
* http://www.brandspankingnew.net/archive/2005/07/format_footnote.html
|
|
*/
|
|
|
|
footnotes: function () {
|
|
// Delete existing footnote entries in case we're reloading the footnodes.
|
|
var i;
|
|
var noteholder = document.getElementById("footnotes");
|
|
if (!noteholder) {
|
|
return;
|
|
}
|
|
var entriesToRemove = [];
|
|
for (i = 0; i < noteholder.childNodes.length; i++) {
|
|
var entry = noteholder.childNodes[i];
|
|
if (entry.nodeName.toLowerCase() == 'div' && entry.getAttribute("class") == "footnote")
|
|
entriesToRemove.push(entry);
|
|
}
|
|
for (i = 0; i < entriesToRemove.length; i++) {
|
|
noteholder.removeChild(entriesToRemove[i]);
|
|
}
|
|
|
|
// Rebuild footnote entries.
|
|
var cont = document.getElementById("content");
|
|
var spans = cont.getElementsByTagName("span");
|
|
var refs = {};
|
|
var n = 0;
|
|
for (i=0; i<spans.length; i++) {
|
|
if (spans[i].className == "footnote") {
|
|
n++;
|
|
var note = spans[i].getAttribute("data-note");
|
|
if (!note) {
|
|
// Use [\s\S] in place of . so multi-line matches work.
|
|
// Because JavaScript has no s (dotall) regex flag.
|
|
note = spans[i].innerHTML.match(/\s*\[([\s\S]*)]\s*/)[1];
|
|
spans[i].innerHTML =
|
|
"[<a id='_footnoteref_" + n + "' href='#_footnote_" + n +
|
|
"' title='View footnote' class='footnote'>" + n + "</a>]";
|
|
spans[i].setAttribute("data-note", note);
|
|
}
|
|
noteholder.innerHTML +=
|
|
"<div class='footnote' id='_footnote_" + n + "'>" +
|
|
"<a href='#_footnoteref_" + n + "' title='Return to text'>" +
|
|
n + "</a>. " + note + "</div>";
|
|
var id =spans[i].getAttribute("id");
|
|
if (id != null) refs["#"+id] = n;
|
|
}
|
|
}
|
|
if (n == 0)
|
|
noteholder.parentNode.removeChild(noteholder);
|
|
else {
|
|
// Process footnoterefs.
|
|
for (i=0; i<spans.length; i++) {
|
|
if (spans[i].className == "footnoteref") {
|
|
var href = spans[i].getElementsByTagName("a")[0].getAttribute("href");
|
|
href = href.match(/#.*/)[0]; // Because IE return full URL.
|
|
n = refs[href];
|
|
spans[i].innerHTML =
|
|
"[<a href='#_footnote_" + n +
|
|
"' title='View footnote' class='footnote'>" + n + "</a>]";
|
|
}
|
|
}
|
|
}
|
|
},
|
|
|
|
install: function(toclevels) {
|
|
var timerId;
|
|
|
|
function reinstall() {
|
|
asciidoc.footnotes();
|
|
if (toclevels) {
|
|
asciidoc.toc(toclevels);
|
|
}
|
|
}
|
|
|
|
function reinstallAndRemoveTimer() {
|
|
clearInterval(timerId);
|
|
reinstall();
|
|
}
|
|
|
|
timerId = setInterval(reinstall, 500);
|
|
if (document.addEventListener)
|
|
document.addEventListener("DOMContentLoaded", reinstallAndRemoveTimer, false);
|
|
else
|
|
window.onload = reinstallAndRemoveTimer;
|
|
}
|
|
|
|
}
|
|
asciidoc.install();
|
|
/*]]>*/
|
|
</script>
|
|
</head>
|
|
<body class="manpage">
|
|
<div id="header">
|
|
<h1>
|
|
git-pack-objects(1) Manual Page
|
|
</h1>
|
|
<h2>NAME</h2>
|
|
<div class="sectionbody">
|
|
<p>git-pack-objects -
|
|
Create a packed archive of objects
|
|
</p>
|
|
</div>
|
|
</div>
|
|
<div id="content">
|
|
<div class="sect1">
|
|
<h2 id="_synopsis">SYNOPSIS</h2>
|
|
<div class="sectionbody">
|
|
<div class="verseblock">
|
|
<pre class="content"><em>git pack-objects</em> [-q | --progress | --all-progress] [--all-progress-implied]
|
|
[--no-reuse-delta] [--delta-base-offset] [--non-empty]
|
|
[--local] [--incremental] [--window=<n>] [--depth=<n>]
|
|
[--revs [--unpacked | --all]] [--keep-pack=<pack-name>]
|
|
[--cruft] [--cruft-expiration=<time>]
|
|
[--stdout [--filter=<filter-spec>] | <base-name>]
|
|
[--shallow] [--keep-true-parents] [--[no-]sparse]
|
|
[--name-hash-version=<n>] [--path-walk] < <object-list></pre>
|
|
<div class="attribution">
|
|
</div></div>
|
|
</div>
|
|
</div>
|
|
<div class="sect1">
|
|
<h2 id="_description">DESCRIPTION</h2>
|
|
<div class="sectionbody">
|
|
<div class="paragraph"><p>Reads list of objects from the standard input, and writes either one or
|
|
more packed archives with the specified base-name to disk, or a packed
|
|
archive to the standard output.</p></div>
|
|
<div class="paragraph"><p>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.</p></div>
|
|
<div class="paragraph"><p>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.</p></div>
|
|
<div class="paragraph"><p>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.</p></div>
|
|
<div class="paragraph"><p>The <em>git unpack-objects</em> 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.</p></div>
|
|
</div>
|
|
</div>
|
|
<div class="sect1">
|
|
<h2 id="_options">OPTIONS</h2>
|
|
<div class="sectionbody">
|
|
<div class="dlist"><dl>
|
|
<dt class="hdlist1">
|
|
base-name
|
|
</dt>
|
|
<dd>
|
|
<p>
|
|
Write into pairs of files (.pack and .idx), using
|
|
<base-name> to determine the name of the created file.
|
|
When this option is used, the two files in a pair are written in
|
|
<base-name>-<SHA-1>.{pack,idx} files. <SHA-1> is a hash
|
|
based on the pack content and is written to the standard
|
|
output of the command.
|
|
</p>
|
|
</dd>
|
|
<dt class="hdlist1">
|
|
--stdout
|
|
</dt>
|
|
<dd>
|
|
<p>
|
|
Write the pack contents (what would have been written to
|
|
.pack file) out to the standard output.
|
|
</p>
|
|
</dd>
|
|
<dt class="hdlist1">
|
|
--revs
|
|
</dt>
|
|
<dd>
|
|
<p>
|
|
Read the revision arguments from the standard input, instead of
|
|
individual object names. The revision arguments are processed
|
|
the same way as <em>git rev-list</em> with the <code>--objects</code> flag
|
|
uses its <code>commit</code> arguments to build the list of objects it
|
|
outputs. The objects on the resulting list are packed.
|
|
Besides revisions, <code>--not</code> or <code>--shallow</code> <em><SHA-1></em> lines are
|
|
also accepted.
|
|
</p>
|
|
</dd>
|
|
<dt class="hdlist1">
|
|
--unpacked
|
|
</dt>
|
|
<dd>
|
|
<p>
|
|
This implies <code>--revs</code>. When processing the list of
|
|
revision arguments read from the standard input, limit
|
|
the objects packed to those that are not already packed.
|
|
</p>
|
|
</dd>
|
|
<dt class="hdlist1">
|
|
--all
|
|
</dt>
|
|
<dd>
|
|
<p>
|
|
This implies <code>--revs</code>. In addition to the list of
|
|
revision arguments read from the standard input, pretend
|
|
as if all refs under <code>refs/</code> are specified to be
|
|
included.
|
|
</p>
|
|
</dd>
|
|
<dt class="hdlist1">
|
|
--include-tag
|
|
</dt>
|
|
<dd>
|
|
<p>
|
|
Include unasked-for annotated tags if the object they
|
|
reference was included in the resulting packfile. This
|
|
can be useful to send new tags to native Git clients.
|
|
</p>
|
|
</dd>
|
|
<dt class="hdlist1">
|
|
--stdin-packs[=<mode>]
|
|
</dt>
|
|
<dd>
|
|
<p>
|
|
Read the basenames of packfiles (e.g., <code>pack-1234abcd.pack</code>)
|
|
from the standard input, instead of object names or revision
|
|
arguments. The resulting pack contains all objects listed in the
|
|
included packs (those not beginning with <code>^</code>), excluding any
|
|
objects listed in the excluded packs (beginning with <code>^</code>).
|
|
</p>
|
|
<div class="paragraph"><p>When <code>mode</code> is "follow", objects from packs not listed on stdin receive
|
|
special treatment. Objects within unlisted packs will be included if
|
|
those objects are (1) reachable from the included packs, and (2) not
|
|
found in any excluded packs. This mode is useful, for example, to
|
|
resurrect once-unreachable objects found in cruft packs to generate
|
|
packs which are closed under reachability up to the boundary set by the
|
|
excluded packs.</p></div>
|
|
<div class="paragraph"><p>Incompatible with <code>--revs</code>, or options that imply <code>--revs</code> (such as
|
|
<code>--all</code>), with the exception of <code>--unpacked</code>, which is compatible.</p></div>
|
|
</dd>
|
|
<dt class="hdlist1">
|
|
--cruft
|
|
</dt>
|
|
<dd>
|
|
<p>
|
|
Packs unreachable objects into a separate "cruft" pack, denoted
|
|
by the existence of a <code>.mtimes</code> file. Typically used by <code>git</code>
|
|
<code>repack</code> <code>--cruft</code>. Callers provide a list of pack names and
|
|
indicate which packs will remain in the repository, along with
|
|
which packs will be deleted (indicated by the <code>-</code> prefix). The
|
|
contents of the cruft pack are all objects not contained in the
|
|
surviving packs which have not exceeded the grace period (see
|
|
<code>--cruft-expiration</code> below), or which have exceeded the grace
|
|
period, but are reachable from an other object which hasn’t.
|
|
</p>
|
|
<div class="paragraph"><p>When the input lists a pack containing all reachable objects (and lists
|
|
all other packs as pending deletion), the corresponding cruft pack will
|
|
contain all unreachable objects (with mtime newer than the
|
|
<code>--cruft-expiration</code>) along with any unreachable objects whose mtime is
|
|
older than the <code>--cruft-expiration</code>, but are reachable from an
|
|
unreachable object whose mtime is newer than the <code>--cruft-expiration</code>).</p></div>
|
|
<div class="paragraph"><p>Incompatible with <code>--unpack-unreachable</code>, <code>--keep-unreachable</code>,
|
|
<code>--pack-loose-unreachable</code>, <code>--stdin-packs</code>, as well as any other
|
|
options which imply <code>--revs</code>.</p></div>
|
|
</dd>
|
|
<dt class="hdlist1">
|
|
--cruft-expiration=<approxidate>
|
|
</dt>
|
|
<dd>
|
|
<p>
|
|
If specified, objects are eliminated from the cruft pack if they
|
|
have an mtime older than <em><approxidate></em>. If unspecified (and
|
|
given <code>--cruft</code>), then no objects are eliminated.
|
|
</p>
|
|
</dd>
|
|
<dt class="hdlist1">
|
|
--window=<n>
|
|
</dt>
|
|
<dt class="hdlist1">
|
|
--depth=<n>
|
|
</dt>
|
|
<dd>
|
|
<p>
|
|
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.
|
|
</p>
|
|
<div class="paragraph"><p>The default value for --window is 10 and --depth is 50. The maximum
|
|
depth is 4095.</p></div>
|
|
</dd>
|
|
<dt class="hdlist1">
|
|
--window-memory=<n>
|
|
</dt>
|
|
<dd>
|
|
<p>
|
|
This option provides an additional limit on top of <code>--window</code>;
|
|
the window size will dynamically scale down so as to not take
|
|
up more than <em><n></em> 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".
|
|
<code>--window-memory=0</code> makes memory usage unlimited. The default
|
|
is taken from the <code>pack.windowMemory</code> configuration variable.
|
|
</p>
|
|
</dd>
|
|
<dt class="hdlist1">
|
|
--max-pack-size=<n>
|
|
</dt>
|
|
<dd>
|
|
<p>
|
|
In unusual scenarios, you may not be able to create files
|
|
larger than a certain size on your filesystem, and this option
|
|
can be used to tell the command to split the output packfile
|
|
into multiple independent packfiles, each not larger than the
|
|
given size. The size can be suffixed with
|
|
"k", "m", or "g". The minimum size allowed is limited to 1 MiB.
|
|
The default is unlimited, unless the config variable
|
|
<code>pack.packSizeLimit</code> is set. Note that this option may result in
|
|
a larger and slower repository; see the discussion in
|
|
<code>pack.packSizeLimit</code>.
|
|
</p>
|
|
</dd>
|
|
<dt class="hdlist1">
|
|
--honor-pack-keep
|
|
</dt>
|
|
<dd>
|
|
<p>
|
|
This flag causes an object already in a local pack that
|
|
has a .keep file to be ignored, even if it would have
|
|
otherwise been packed.
|
|
</p>
|
|
</dd>
|
|
<dt class="hdlist1">
|
|
--keep-pack=<pack-name>
|
|
</dt>
|
|
<dd>
|
|
<p>
|
|
This flag causes an object already in the given pack to be
|
|
ignored, even if it would have otherwise been
|
|
packed. <em><pack-name></em> is the pack file name without
|
|
leading directory (e.g. <code>pack-123.pack</code>). The option could be
|
|
specified multiple times to keep multiple packs.
|
|
</p>
|
|
</dd>
|
|
<dt class="hdlist1">
|
|
--incremental
|
|
</dt>
|
|
<dd>
|
|
<p>
|
|
This flag causes an object already in a pack to be ignored
|
|
even if it would have otherwise been packed.
|
|
</p>
|
|
</dd>
|
|
<dt class="hdlist1">
|
|
--local
|
|
</dt>
|
|
<dd>
|
|
<p>
|
|
This flag causes an object that is borrowed from an alternate
|
|
object store to be ignored even if it would have otherwise been
|
|
packed.
|
|
</p>
|
|
</dd>
|
|
<dt class="hdlist1">
|
|
--non-empty
|
|
</dt>
|
|
<dd>
|
|
<p>
|
|
Only create a packed archive if it would contain at
|
|
least one object.
|
|
</p>
|
|
</dd>
|
|
<dt class="hdlist1">
|
|
--progress
|
|
</dt>
|
|
<dd>
|
|
<p>
|
|
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.
|
|
</p>
|
|
</dd>
|
|
<dt class="hdlist1">
|
|
--all-progress
|
|
</dt>
|
|
<dd>
|
|
<p>
|
|
When --stdout is specified then progress report is
|
|
displayed during the object count and compression phases
|
|
but inhibited during the write-out phase. The reason is
|
|
that in some cases the output stream is directly linked
|
|
to another command which may wish to display progress
|
|
status of its own as it processes incoming pack data.
|
|
This flag is like --progress except that it forces progress
|
|
report for the write-out phase as well even if --stdout is
|
|
used.
|
|
</p>
|
|
</dd>
|
|
<dt class="hdlist1">
|
|
--all-progress-implied
|
|
</dt>
|
|
<dd>
|
|
<p>
|
|
This is used to imply --all-progress whenever progress display
|
|
is activated. Unlike --all-progress this flag doesn’t actually
|
|
force any progress display by itself.
|
|
</p>
|
|
</dd>
|
|
<dt class="hdlist1">
|
|
-q
|
|
</dt>
|
|
<dd>
|
|
<p>
|
|
This flag makes the command not to report its progress
|
|
on the standard error stream.
|
|
</p>
|
|
</dd>
|
|
<dt class="hdlist1">
|
|
--no-reuse-delta
|
|
</dt>
|
|
<dd>
|
|
<p>
|
|
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.
|
|
</p>
|
|
</dd>
|
|
<dt class="hdlist1">
|
|
--no-reuse-object
|
|
</dt>
|
|
<dd>
|
|
<p>
|
|
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.
|
|
</p>
|
|
</dd>
|
|
<dt class="hdlist1">
|
|
--compression=<n>
|
|
</dt>
|
|
<dd>
|
|
<p>
|
|
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.
|
|
</p>
|
|
</dd>
|
|
<dt class="hdlist1">
|
|
--[no-]sparse
|
|
</dt>
|
|
<dd>
|
|
<p>
|
|
Toggle the "sparse" algorithm to determine which objects to include in
|
|
the pack, when combined with the "--revs" option. This algorithm
|
|
only walks trees that appear in paths that introduce new objects.
|
|
This can have significant performance benefits when computing
|
|
a pack to send a small change. However, it is possible that extra
|
|
objects are added to the pack-file if the included commits contain
|
|
certain types of direct renames. If this option is not included,
|
|
it defaults to the value of <code>pack.useSparse</code>, which is true unless
|
|
otherwise specified.
|
|
</p>
|
|
</dd>
|
|
<dt class="hdlist1">
|
|
--thin
|
|
</dt>
|
|
<dd>
|
|
<p>
|
|
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.
|
|
</p>
|
|
<div class="paragraph"><p>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 <code>git</code> <code>index-pack</code> <code>--fix-thin</code>
|
|
(see <a href="git-index-pack.html">git-index-pack(1)</a>) to restore the self-contained property.</p></div>
|
|
</dd>
|
|
<dt class="hdlist1">
|
|
--shallow
|
|
</dt>
|
|
<dd>
|
|
<p>
|
|
Optimize a pack that will be provided to a client with a shallow
|
|
repository. This option, combined with --thin, can result in a
|
|
smaller pack at the cost of speed.
|
|
</p>
|
|
</dd>
|
|
<dt class="hdlist1">
|
|
--delta-base-offset
|
|
</dt>
|
|
<dd>
|
|
<p>
|
|
A packed archive can express the base object of a delta as
|
|
either a 20-byte object name or as an offset in the
|
|
stream, but ancient versions of Git don’t understand the
|
|
latter. By default, <em>git pack-objects</em> 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.
|
|
</p>
|
|
<div class="paragraph"><p>Note: Porcelain commands such as <code>git</code> <code>gc</code> (see <a href="git-gc.html">git-gc(1)</a>),
|
|
<code>git</code> <code>repack</code> (see <a href="git-repack.html">git-repack(1)</a>) pass this option by default
|
|
in modern Git when they put objects in your repository into pack files.
|
|
So does <code>git</code> <code>bundle</code> (see <a href="git-bundle.html">git-bundle(1)</a>) when it creates a bundle.</p></div>
|
|
</dd>
|
|
<dt class="hdlist1">
|
|
--threads=<n>
|
|
</dt>
|
|
<dd>
|
|
<p>
|
|
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 accordingly.
|
|
</p>
|
|
</dd>
|
|
<dt class="hdlist1">
|
|
--index-version=<version>[,<offset>]
|
|
</dt>
|
|
<dd>
|
|
<p>
|
|
This is intended to be used by the test suite only. It allows
|
|
to force the version for the generated pack index, and to force
|
|
64-bit index entries on objects located above the given offset.
|
|
</p>
|
|
</dd>
|
|
<dt class="hdlist1">
|
|
--keep-true-parents
|
|
</dt>
|
|
<dd>
|
|
<p>
|
|
With this option, parents that are hidden by grafts are packed
|
|
nevertheless.
|
|
</p>
|
|
</dd>
|
|
<dt class="hdlist1">
|
|
--filter=<filter-spec>
|
|
</dt>
|
|
<dd>
|
|
<p>
|
|
Omits certain objects (usually blobs) from the resulting
|
|
packfile. See <a href="git-rev-list.html">git-rev-list(1)</a> for valid
|
|
<em><filter-spec></em> forms.
|
|
</p>
|
|
</dd>
|
|
<dt class="hdlist1">
|
|
--no-filter
|
|
</dt>
|
|
<dd>
|
|
<p>
|
|
Turns off any previous <code>--filter=</code> argument.
|
|
</p>
|
|
</dd>
|
|
<dt class="hdlist1">
|
|
--missing=<missing-action>
|
|
</dt>
|
|
<dd>
|
|
<p>
|
|
A debug option to help with future "partial clone" development.
|
|
This option specifies how missing objects are handled.
|
|
</p>
|
|
<div class="paragraph"><p>The form <em>--missing=error</em> requests that pack-objects stop with an error if
|
|
a missing object is encountered. If the repository is a partial clone, an
|
|
attempt to fetch missing objects will be made before declaring them missing.
|
|
This is the default action.</p></div>
|
|
<div class="paragraph"><p>The form <em>--missing=allow-any</em> will allow object traversal to continue
|
|
if a missing object is encountered. No fetch of a missing object will occur.
|
|
Missing objects will silently be omitted from the results.</p></div>
|
|
<div class="paragraph"><p>The form <em>--missing=allow-promisor</em> is like <em>allow-any</em>, but will only
|
|
allow object traversal to continue for EXPECTED promisor missing objects.
|
|
No fetch of a missing object will occur. An unexpected missing object will
|
|
raise an error.</p></div>
|
|
</dd>
|
|
<dt class="hdlist1">
|
|
--exclude-promisor-objects
|
|
</dt>
|
|
<dd>
|
|
<p>
|
|
Omit objects that are known to be in the promisor remote. (This
|
|
option has the purpose of operating only on locally created objects,
|
|
so that when we repack, we still maintain a distinction between
|
|
locally created objects [without .promisor] and objects from the
|
|
promisor remote [with .promisor].) This is used with partial clone.
|
|
</p>
|
|
</dd>
|
|
<dt class="hdlist1">
|
|
--keep-unreachable
|
|
</dt>
|
|
<dd>
|
|
<p>
|
|
Objects unreachable from the refs in packs named with
|
|
--unpacked= option are added to the resulting pack, in
|
|
addition to the reachable objects that are not in packs marked
|
|
with *.keep files. This implies <code>--revs</code>.
|
|
</p>
|
|
</dd>
|
|
<dt class="hdlist1">
|
|
--pack-loose-unreachable
|
|
</dt>
|
|
<dd>
|
|
<p>
|
|
Pack unreachable loose objects (and their loose counterparts
|
|
removed). This implies <code>--revs</code>.
|
|
</p>
|
|
</dd>
|
|
<dt class="hdlist1">
|
|
--unpack-unreachable
|
|
</dt>
|
|
<dd>
|
|
<p>
|
|
Keep unreachable objects in loose form. This implies <code>--revs</code>.
|
|
</p>
|
|
</dd>
|
|
<dt class="hdlist1">
|
|
--delta-islands
|
|
</dt>
|
|
<dd>
|
|
<p>
|
|
Restrict delta matches based on "islands". See DELTA ISLANDS
|
|
below.
|
|
</p>
|
|
</dd>
|
|
<dt class="hdlist1">
|
|
--name-hash-version=<n>
|
|
</dt>
|
|
<dd>
|
|
<p>
|
|
While performing delta compression, Git groups objects that may be
|
|
similar based on heuristics using the path to that object. While
|
|
grouping objects by an exact path match is good for paths with
|
|
many versions, there are benefits for finding delta pairs across
|
|
different full paths. Git collects objects by type and then by a
|
|
"name hash" of the path and then by size, hoping to group objects
|
|
that will compress well together.
|
|
</p>
|
|
<div class="paragraph"><p>The default name hash version is <code>1</code>, which prioritizes hash locality by
|
|
considering the final bytes of the path as providing the maximum magnitude
|
|
to the hash function. This version excels at distinguishing short paths
|
|
and finding renames across directories. However, the hash function depends
|
|
primarily on the final 16 bytes of the path. If there are many paths in
|
|
the repo that have the same final 16 bytes and differ only by parent
|
|
directory, then this name-hash may lead to too many collisions and cause
|
|
poor results. At the moment, this version is required when writing
|
|
reachability bitmap files with <code>--write-bitmap-index</code>.</p></div>
|
|
<div class="paragraph"><p>The name hash version <code>2</code> has similar locality features as version <code>1</code>,
|
|
except it considers each path component separately and overlays the hashes
|
|
with a shift. This still prioritizes the final bytes of the path, but also
|
|
"salts" the lower bits of the hash using the parent directory names. This
|
|
method allows for some of the locality benefits of version <code>1</code> while
|
|
breaking most of the collisions from a similarly-named file appearing in
|
|
many different directories. At the moment, this version is not allowed
|
|
when writing reachability bitmap files with <code>--write-bitmap-index</code> and it
|
|
will be automatically changed to version <code>1</code>.</p></div>
|
|
</dd>
|
|
<dt class="hdlist1">
|
|
--path-walk
|
|
</dt>
|
|
<dd>
|
|
<p>
|
|
Perform compression by first organizing objects by path, then a
|
|
second pass that compresses across paths as normal. This has the
|
|
potential to improve delta compression especially in the presence
|
|
of filenames that cause collisions in Git’s default name-hash
|
|
algorithm.
|
|
</p>
|
|
<div class="paragraph"><p>Incompatible with <code>--delta-islands</code>, <code>--shallow</code>, or <code>--filter</code>. The
|
|
<code>--use-bitmap-index</code> option will be ignored in the presence of
|
|
<code>--path-walk.</code></p></div>
|
|
</dd>
|
|
</dl></div>
|
|
</div>
|
|
</div>
|
|
<div class="sect1">
|
|
<h2 id="_delta_islands">DELTA ISLANDS</h2>
|
|
<div class="sectionbody">
|
|
<div class="paragraph"><p>When possible, <code>pack-objects</code> tries to reuse existing on-disk deltas to
|
|
avoid having to search for new ones on the fly. This is an important
|
|
optimization for serving fetches, because it means the server can avoid
|
|
inflating most objects at all and just send the bytes directly from
|
|
disk. This optimization can’t work when an object is stored as a delta
|
|
against a base which the receiver does not have (and which we are not
|
|
already sending). In that case the server "breaks" the delta and has to
|
|
find a new one, which has a high CPU cost. Therefore it’s important for
|
|
performance that the set of objects in on-disk delta relationships match
|
|
what a client would fetch.</p></div>
|
|
<div class="paragraph"><p>In a normal repository, this tends to work automatically. The objects
|
|
are mostly reachable from the branches and tags, and that’s what clients
|
|
fetch. Any deltas we find on the server are likely to be between objects
|
|
the client has or will have.</p></div>
|
|
<div class="paragraph"><p>But in some repository setups, you may have several related but separate
|
|
groups of ref tips, with clients tending to fetch those groups
|
|
independently. For example, imagine that you are hosting several "forks"
|
|
of a repository in a single shared object store, and letting clients
|
|
view them as separate repositories through <code>GIT_NAMESPACE</code> or separate
|
|
repos using the alternates mechanism. A naive repack may find that the
|
|
optimal delta for an object is against a base that is only found in
|
|
another fork. But when a client fetches, they will not have the base
|
|
object, and we’ll have to find a new delta on the fly.</p></div>
|
|
<div class="paragraph"><p>A similar situation may exist if you have many refs outside of
|
|
<code>refs/heads/</code> and <code>refs/tags/</code> that point to related objects (e.g.,
|
|
<code>refs/pull</code> or <code>refs/changes</code> used by some hosting providers). By
|
|
default, clients fetch only heads and tags, and deltas against objects
|
|
found only in those other groups cannot be sent as-is.</p></div>
|
|
<div class="paragraph"><p>Delta islands solve this problem by allowing you to group your refs into
|
|
distinct "islands". Pack-objects computes which objects are reachable
|
|
from which islands, and refuses to make a delta from an object <code>A</code>
|
|
against a base which is not present in all of <code>A</code>'s islands. This
|
|
results in slightly larger packs (because we miss some delta
|
|
opportunities), but guarantees that a fetch of one island will not have
|
|
to recompute deltas on the fly due to crossing island boundaries.</p></div>
|
|
<div class="paragraph"><p>When repacking with delta islands the delta window tends to get
|
|
clogged with candidates that are forbidden by the config. Repacking
|
|
with a big --window helps (and doesn’t take as long as it otherwise
|
|
might because we can reject some object pairs based on islands before
|
|
doing any computation on the content).</p></div>
|
|
<div class="paragraph"><p>Islands are configured via the <code>pack.island</code> option, which can be
|
|
specified multiple times. Each value is a left-anchored regular
|
|
expressions matching refnames. For example:</p></div>
|
|
<div class="listingblock">
|
|
<div class="content">
|
|
<pre><code>[pack]
|
|
island = refs/heads/
|
|
island = refs/tags/</code></pre>
|
|
</div></div>
|
|
<div class="paragraph"><p>puts heads and tags into an island (whose name is the empty string; see
|
|
below for more on naming). Any refs which do not match those regular
|
|
expressions (e.g., <code>refs/pull/123</code>) is not in any island. Any object
|
|
which is reachable only from <code>refs/pull/</code> (but not heads or tags) is
|
|
therefore not a candidate to be used as a base for <code>refs/heads/</code>.</p></div>
|
|
<div class="paragraph"><p>Refs are grouped into islands based on their "names", and two regexes
|
|
that produce the same name are considered to be in the same
|
|
island. The names are computed from the regexes by concatenating any
|
|
capture groups from the regex, with a <em>-</em> dash in between. (And if
|
|
there are no capture groups, then the name is the empty string, as in
|
|
the above example.) This allows you to create arbitrary numbers of
|
|
islands. Only up to 14 such capture groups are supported though.</p></div>
|
|
<div class="paragraph"><p>For example, imagine you store the refs for each fork in
|
|
<code>refs/virtual/ID</code>, where <code>ID</code> is a numeric identifier. You might then
|
|
configure:</p></div>
|
|
<div class="listingblock">
|
|
<div class="content">
|
|
<pre><code>[pack]
|
|
island = refs/virtual/([0-9]+)/heads/
|
|
island = refs/virtual/([0-9]+)/tags/
|
|
island = refs/virtual/([0-9]+)/(pull)/</code></pre>
|
|
</div></div>
|
|
<div class="paragraph"><p>That puts the heads and tags for each fork in their own island (named
|
|
"1234" or similar), and the pull refs for each go into their own
|
|
"1234-pull".</p></div>
|
|
<div class="paragraph"><p>Note that we pick a single island for each regex to go into, using "last
|
|
one wins" ordering (which allows repo-specific config to take precedence
|
|
over user-wide config, and so forth).</p></div>
|
|
</div>
|
|
</div>
|
|
<div class="sect1">
|
|
<h2 id="_configuration">CONFIGURATION</h2>
|
|
<div class="sectionbody">
|
|
<div class="paragraph"><p>Various configuration variables affect packing, see
|
|
<a href="git-config.html">git-config(1)</a> (search for "pack" and "delta").</p></div>
|
|
<div class="paragraph"><p>Notably, delta compression is not used on objects larger than the
|
|
<code>core.bigFileThreshold</code> configuration variable and on files with the
|
|
attribute <code>delta</code> set to false.</p></div>
|
|
</div>
|
|
</div>
|
|
<div class="sect1">
|
|
<h2 id="_see_also">SEE ALSO</h2>
|
|
<div class="sectionbody">
|
|
<div class="paragraph"><p><a href="git-rev-list.html">git-rev-list(1)</a>
|
|
<a href="git-repack.html">git-repack(1)</a>
|
|
<a href="git-prune-packed.html">git-prune-packed(1)</a></p></div>
|
|
</div>
|
|
</div>
|
|
<div class="sect1">
|
|
<h2 id="_git">GIT</h2>
|
|
<div class="sectionbody">
|
|
<div class="paragraph"><p>Part of the <a href="git.html">git(1)</a> suite</p></div>
|
|
</div>
|
|
</div>
|
|
</div>
|
|
<div id="footnotes"><hr /></div>
|
|
<div id="footer">
|
|
<div id="footer-text">
|
|
Last updated
|
|
2025-08-18 02:18:23 CEST
|
|
</div>
|
|
</div>
|
|
</body>
|
|
</html>
|