@ -80,13 +80,6 @@ final class DeltaWindow {
// The object we are currently considering needs a lot of state:
/ * *
* Maximum delta chain depth the current object can have .
* < p >
* This can be smaller than { @link # maxDepth } .
* /
private int resMaxDepth ;
/** Window entry of the object we are currently considering. */
private DeltaWindowEntry res ;
@ -206,31 +199,21 @@ final class DeltaWindow {
}
private void searchInWindow ( ) throws IOException {
// TODO(spearce) If the object is used as a base for other
// objects in this pack we should limit the depth we create
// for ourselves to be the remainder of our longest dependent
// chain and the configured maximum depth. This can happen
// when the dependents are being reused out a pack, but we
// cannot be because we are near the edge of a thin pack.
//
resMaxDepth = maxDepth ;
// Loop through the window backwards, considering every entry.
// This lets us look at the bigger objects that came before.
//
for ( DeltaWindowEntry src = res . prev ; src ! = res ; src = src . prev ) {
if ( src . empty ( ) )
break ;
if ( delta ( src ) /* == NEXT_SRC */ )
continue ;
bestBase = null ;
bestDelta = null ;
return ;
}
// We couldn't find a suitable delta for this object, but it may
// still be able to act as a base for another one.
//
if ( bestDelta = = null ) {
if ( bestBase = = null ) {
keepInWindow ( ) ;
return ;
}
@ -245,76 +228,60 @@ final class DeltaWindow {
// has on hand, so we don't want to send it. We have to store
// an ObjectId and *NOT* an ObjectToPack for the base to ensure
// the base isn't included in the outgoing pack file.
//
resObj . setDeltaBase ( srcObj . copy ( ) ) ;
} else {
// The base is part of the pack we are sending, so it should be
// a direct pointer to the base.
//
resObj . setDeltaBase ( srcObj ) ;
}
resObj . setDeltaDepth ( srcObj . getDeltaDepth ( ) + 1 ) ;
int depth = srcObj . getDeltaDepth ( ) + 1 ;
resObj . setDeltaDepth ( depth ) ;
resObj . clearReuseAsIs ( ) ;
cacheDelta ( srcObj , resObj ) ;
// Discard the cached best result, otherwise it leaks.
//
bestDelta = null ;
// If this should be the end of a chain, don't keep
// it in the window. Just move on to the next object.
//
if ( resObj . getDeltaDepth ( ) = = maxDepth )
return ;
if ( depth < maxDepth ) {
// Reorder the window so that the best base will be tested
// first for the next object, and the current object will
// be the second candidate to consider before any others.
res . makeNext ( bestBase ) ;
res = bestBase . next ;
}
shuffleBaseUpInPriority ( ) ;
keepInWindow ( ) ;
bestBase = null ;
bestDelta = null ;
}
private boolean delta ( final DeltaWindowEntry src )
throws IOException {
// Objects must use only the same type as their delta base.
// If we are looking at something where that isn't true we
// have exhausted everything of the correct type and should
// move on to the next thing to examine.
//
if ( src . type ( ) ! = res . type ( ) ) {
keepInWindow ( ) ;
return NEXT_RES ;
}
// Only consider a source with a short enough delta chain .
if ( src . depth ( ) > resMaxDepth )
// If the sizes are radically different, this is a bad pairing .
if ( res . size ( ) < src . size ( ) > > > 4 )
return NEXT_SRC ;
// Estimate a reasonable upper limit on delta size.
int msz = deltaSizeLimit ( res , resMaxDepth , src ) ;
if ( msz < = 8 )
int msz = deltaSizeLimit ( src ) ;
if ( msz < = 8 ) // Nearly impossible to fit useful delta.
return NEXT_SRC ;
// If we have to insert a lot to make this work, find another.
if ( res . size ( ) - src . size ( ) > msz )
return NEXT_SRC ;
// If the sizes are radically different, this is a bad pairing.
if ( res . size ( ) < src . size ( ) / 16 )
return NEXT_SRC ;
DeltaIndex srcIndex ;
try {
srcIndex = index ( src ) ;
} catch ( LargeObjectException tooBig ) {
// If the source is too big to work on, skip it.
dropFromWindow ( src ) ;
return NEXT_SRC ;
} catch ( IOException notAvailable ) {
if ( src . object . isEdge ( ) ) {
// This is an edge that is suddenly not available.
dropFromWindow ( src ) ;
if ( src . object . isEdge ( ) ) // Missing edges are OK.
return NEXT_SRC ;
} else {
throw notAvailable ;
}
throw notAvailable ;
}
byte [ ] resBuf ;
@ -325,26 +292,41 @@ final class DeltaWindow {
return NEXT_RES ;
}
// If we already have a delta for the current object, abort
// encoding early if this new pairing produces a larger delta.
if ( bestDelta ! = null & & bestDelta . length ( ) < msz )
msz = ( int ) bestDelta . length ( ) ;
TemporaryBuffer . Heap delta = new TemporaryBuffer . Heap ( msz ) ;
try {
if ( ! srcIndex . encode ( delta , resBuf , msz ) )
return NEXT_SRC ;
TemporaryBuffer . Heap delta = new TemporaryBuffer . Heap ( msz ) ;
if ( srcIndex . encode ( delta , resBuf , msz ) ) {
bestBase = src ;
bestDelta = delta ;
}
} catch ( IOException deltaTooBig ) {
// This only happens when the heap overflows our limit.
return NEXT_SRC ;
// Unlikely, encoder should see limit and return false.
}
return NEXT_SRC ;
}
if ( isBetterDelta ( src , delta ) ) {
bestDelta = delta ;
bestBase = src ;
private int deltaSizeLimit ( DeltaWindowEntry src ) {
if ( bestBase = = null ) {
// Any delta should be no more than 50% of the original size
// (for text files deflate of whole form should shrink 50%).
int n = res . size ( ) > > > 1 ;
// Evenly distribute delta size limits over allowed depth.
// If src is non-delta (depth = 0), delta <= 50% of original.
// If src is almost at limit (9/10), delta <= 10% of original.
return n * ( maxDepth - src . depth ( ) ) / maxDepth ;
}
return NEXT_SRC ;
// With a delta base chosen any new delta must be "better".
// Retain the distribution described above.
int d = bestBase . depth ( ) ;
int n = ( int ) bestDelta . length ( ) ;
// If src is whole (depth=0) and base is near limit (depth=9/10)
// any delta using src can be 10x larger and still be better.
//
// If src is near limit (depth=9/10) and base is whole (depth=0)
// a new delta dependent on src must be 1/10th the size.
return n * ( maxDepth - src . depth ( ) ) / ( maxDepth - d ) ;
}
private void cacheDelta ( ObjectToPack srcObj , ObjectToPack resObj ) {
@ -375,56 +357,10 @@ final class DeltaWindow {
return insz + ( ( insz + 7 ) > > 3 ) + ( ( insz + 63 ) > > 6 ) + 11 ;
}
private void shuffleBaseUpInPriority ( ) {
// Reorder the window so that the best match we just used
// is the current one, and the now current object is before.
res . makeNext ( bestBase ) ;
res = bestBase ;
}
private void keepInWindow ( ) {
res = res . next ;
}
private void dropFromWindow ( @SuppressWarnings ( "unused" ) DeltaWindowEntry src ) {
// We should drop the current source entry from the window,
// it is somehow invalid for us to work with.
}
private boolean isBetterDelta ( DeltaWindowEntry src ,
TemporaryBuffer . Heap resDelta ) {
if ( bestDelta = = null )
return true ;
// If both delta sequences are the same length, use the one
// that has a shorter delta chain since it would be faster
// to access during reads.
//
if ( resDelta . length ( ) = = bestDelta . length ( ) )
return src . depth ( ) < bestBase . depth ( ) ;
return resDelta . length ( ) < bestDelta . length ( ) ;
}
private static int deltaSizeLimit ( DeltaWindowEntry res , int maxDepth ,
DeltaWindowEntry src ) {
// Ideally the delta is at least 50% of the original size,
// but we also want to account for delta header overhead in
// the pack file (to point to the delta base) so subtract off
// some of those header bytes from the limit.
//
final int limit = res . size ( ) / 2 - 20 ;
// Distribute the delta limit over the entire chain length.
// This is weighted such that deeper items in the chain must
// be even smaller than if they were earlier in the chain, as
// they cost significantly more to unpack due to the increased
// number of recursive unpack calls.
//
final int remainingDepth = maxDepth - src . depth ( ) ;
return ( limit * remainingDepth ) / maxDepth ;
}
private DeltaIndex index ( DeltaWindowEntry ent )
throws MissingObjectException , IncorrectObjectTypeException ,
IOException , LargeObjectException {
Shawn Pearce
12 years ago
committed by
Shawn Pearce