Beispiel #1
0
		internal DeltaBaseCache GetDeltaBaseCache()
		{
			if (baseCache == null)
			{
				baseCache = new DeltaBaseCache();
			}
			return baseCache;
		}
Beispiel #2
0
 internal DeltaBaseCache GetDeltaBaseCache()
 {
     if (baseCache == null)
     {
         baseCache = new DeltaBaseCache();
     }
     return(baseCache);
 }
Beispiel #3
0
 /// <summary>Close the resources utilized by this repository</summary>
 public virtual void Close()
 {
     DeltaBaseCache.Purge(this);
     WindowCache.Purge(this);
     lock (this)
     {
         loadedIdx  = null;
         reverseIdx = null;
     }
 }
Beispiel #4
0
 /// <summary>Modify the configuration of the window cache.</summary>
 /// <remarks>
 /// Modify the configuration of the window cache.
 /// <p>
 /// The new configuration is applied immediately. If the new limits are
 /// smaller than what what is currently cached, older entries will be purged
 /// as soon as possible to allow the cache to meet the new limit.
 /// </remarks>
 /// <param name="cfg">the new window cache configuration.</param>
 /// <exception cref="System.ArgumentException">
 /// the cache configuration contains one or more invalid
 /// settings, usually too low of a limit.
 /// </exception>
 public static void Reconfigure(WindowCacheConfig cfg)
 {
     NGit.Storage.File.WindowCache nc = new NGit.Storage.File.WindowCache(cfg);
     NGit.Storage.File.WindowCache oc = cache;
     if (oc != null)
     {
         oc.RemoveAll();
     }
     cache = nc;
     streamFileThreshold = cfg.GetStreamFileThreshold();
     DeltaBaseCache.Reconfigure(cfg);
 }
Beispiel #5
0
 /// <summary>Release the current window cursor.</summary>
 /// <remarks>Release the current window cursor.</remarks>
 public override void Release()
 {
     window    = null;
     baseCache = null;
     try
     {
         InflaterCache.Release(inf);
     }
     finally
     {
         inf = null;
     }
 }
Beispiel #6
0
		/// <summary>Release the current window cursor.</summary>
		/// <remarks>Release the current window cursor.</remarks>
		public override void Release()
		{
			window = null;
			baseCache = null;
			try
			{
				InflaterCache.Release(inf);
			}
			finally
			{
				inf = null;
			}
		}
Beispiel #7
0
        /// <exception cref="System.IO.IOException"></exception>
        internal virtual ObjectLoader Load(WindowCursor curs, long pos)
        {
            try
            {
                byte[]         ib     = curs.tempId;
                PackFile.Delta delta  = null;
                byte[]         data   = null;
                int            type   = Constants.OBJ_BAD;
                bool           cached = false;
                for (; ;)
                {
                    ReadFully(pos, ib, 0, 20, curs);
                    int  c        = ib[0] & unchecked ((int)(0xff));
                    int  typeCode = (c >> 4) & 7;
                    long sz       = c & 15;
                    int  shift    = 4;
                    int  p        = 1;
                    while ((c & unchecked ((int)(0x80))) != 0)
                    {
                        c      = ib[p++] & unchecked ((int)(0xff));
                        sz    += (c & unchecked ((int)(0x7f))) << shift;
                        shift += 7;
                    }
                    switch (typeCode)
                    {
                    case Constants.OBJ_COMMIT:
                    case Constants.OBJ_TREE:
                    case Constants.OBJ_BLOB:
                    case Constants.OBJ_TAG:
                    {
                        if (sz < curs.GetStreamFileThreshold())
                        {
                            data = Decompress(pos + p, (int)sz, curs);
                        }
                        if (delta != null)
                        {
                            type = typeCode;
                            goto SEARCH_break;
                        }
                        if (data != null)
                        {
                            return(new ObjectLoader.SmallObject(typeCode, data));
                        }
                        else
                        {
                            return(new LargePackedWholeObject(typeCode, sz, pos, p, this, curs.db));
                        }
                        goto case Constants.OBJ_OFS_DELTA;
                    }

                    case Constants.OBJ_OFS_DELTA:
                    {
                        c = ib[p++] & unchecked ((int)(0xff));
                        long @base = c & 127;
                        while ((c & 128) != 0)
                        {
                            @base  += 1;
                            c       = ib[p++] & unchecked ((int)(0xff));
                            @base <<= 7;
                            @base  += (c & 127);
                        }
                        @base = pos - @base;
                        delta = new PackFile.Delta(delta, pos, (int)sz, p, @base);
                        if (sz != delta.deltaSize)
                        {
                            goto SEARCH_break;
                        }
                        DeltaBaseCache.Entry e = DeltaBaseCache.Get(this, @base);
                        if (e != null)
                        {
                            type   = e.type;
                            data   = e.data;
                            cached = true;
                            goto SEARCH_break;
                        }
                        pos = @base;
                        goto SEARCH_continue;
                    }

                    case Constants.OBJ_REF_DELTA:
                    {
                        ReadFully(pos + p, ib, 0, 20, curs);
                        long @base = FindDeltaBase(ObjectId.FromRaw(ib));
                        delta = new PackFile.Delta(delta, pos, (int)sz, p + 20, @base);
                        if (sz != delta.deltaSize)
                        {
                            goto SEARCH_break;
                        }
                        DeltaBaseCache.Entry e = DeltaBaseCache.Get(this, @base);
                        if (e != null)
                        {
                            type   = e.type;
                            data   = e.data;
                            cached = true;
                            goto SEARCH_break;
                        }
                        pos = @base;
                        goto SEARCH_continue;
                    }

                    default:
                    {
                        throw new IOException(MessageFormat.Format(JGitText.Get().unknownObjectType, typeCode
                                                                   ));
                    }
                    }
                    SEARCH_continue :;
                }
                SEARCH_break :;
                // At this point there is at least one delta to apply to data.
                // (Whole objects with no deltas to apply return early above.)
                if (data == null)
                {
                    return(delta.Large(this, curs));
                }
                do
                {
                    // Cache only the base immediately before desired object.
                    if (cached)
                    {
                        cached = false;
                    }
                    else
                    {
                        if (delta.next == null)
                        {
                            DeltaBaseCache.Store(this, delta.basePos, data, type);
                        }
                    }
                    pos = delta.deltaPos;
                    byte[] cmds = Decompress(pos + delta.hdrLen, delta.deltaSize, curs);
                    if (cmds == null)
                    {
                        data = null;
                        // Discard base in case of OutOfMemoryError
                        return(delta.Large(this, curs));
                    }
                    long sz = BinaryDelta.GetResultSize(cmds);
                    if (int.MaxValue <= sz)
                    {
                        return(delta.Large(this, curs));
                    }
                    byte[] result;
                    try
                    {
                        result = new byte[(int)sz];
                    }
                    catch (OutOfMemoryException)
                    {
                        data = null;
                        // Discard base in case of OutOfMemoryError
                        return(delta.Large(this, curs));
                    }
                    BinaryDelta.Apply(data, cmds, result);
                    data  = result;
                    delta = delta.next;
                }while (delta != null);
                return(new ObjectLoader.SmallObject(type, data));
            }
            catch (SharpZipBaseException dfe)
            {
                CorruptObjectException coe = new CorruptObjectException(MessageFormat.Format(JGitText
                                                                                             .Get().objectAtHasBadZlibStream, pos, GetPackFile()));
                Sharpen.Extensions.InitCause(coe, dfe);
                throw coe;
            }
        }
		private static void ClearEntry(DeltaBaseCache.Slot e)
		{
			openByteCount -= e.sz;
			e.provider = null;
			e.data = DEAD;
			e.sz = 0;
		}
		private static void Unlink(DeltaBaseCache.Slot e)
		{
			DeltaBaseCache.Slot prev = e.lruPrev;
			DeltaBaseCache.Slot next = e.lruNext;
			if (prev != null)
			{
				prev.lruNext = next;
			}
			if (next != null)
			{
				next.lruPrev = prev;
			}
		}
		private static void MoveToHead(DeltaBaseCache.Slot e)
		{
			Unlink(e);
			e.lruPrev = null;
			e.lruNext = lruHead;
			if (lruHead != null)
			{
				lruHead.lruPrev = e;
			}
			else
			{
				lruTail = e;
			}
			lruHead = e;
		}