private void WriteItem(BaseReference itemRef) { ItemHolder item = itemRef.Item; IStorable item2 = item.Item; ReferenceID id = itemRef.Id; long num = m_storage.Allocate(item2); if (id.HasMultiPart && !id.IsTemporary) { m_partitionManager.UpdateTreePartitionOffset(id, num); if (itemRef.PinCount == 0) { CacheRemoveValue(id); } } else { id = new ReferenceID(num); id.IsTemporary = false; id.HasMultiPart = false; itemRef.Id = id; } if (itemRef.PinCount == 0) { item.Item = null; item.Reference = null; itemRef.Item = null; } }
public void Add(ItemHolder item) { m_count++; item.Next = m_sentinal; item.Previous = m_sentinal.Previous; m_sentinal.Previous.Next = item; m_sentinal.Previous = item; }
public void Bump(ItemHolder item) { item.Previous.Next = item.Next; item.Next.Previous = item.Previous; item.Next = m_sentinal; item.Previous = m_sentinal.Previous; m_sentinal.Previous.Next = item; m_sentinal.Previous = item; }
public T ExtractLRU() { if (m_count == 0) { Global.Tracer.Assert(condition: false, "Cannot ExtractLRU from empty cache"); } ItemHolder next = m_sentinal.Next; Remove(next); return((T)next); }
protected sealed override void FulfillInProgressFree() { int num = m_cachePriority.Count; while (m_inProgressFreeBytes > 0 && num > 0) { num--; ItemHolder itemHolder = m_cachePriority.Peek(); BaseReference reference = itemHolder.Reference; if (reference.PinCount == 0) { m_cachePriority.ExtractLRU(); reference.InQueue = InQueueState.None; if (itemHolder.Item != null) { UpdateStatsForRemovedItem(reference, ref m_inProgressFreeBytes); CacheRemoveValue(reference.Id); itemHolder.Item = null; itemHolder.Reference = null; reference.Item = null; } } else { m_cachePriority.Bump(itemHolder); } } if (m_inProgressFreeBytes <= 0) { return; } using (IDecumulator <BaseReference> decumulator = m_serializationQueue.GetDecumulator()) { while (m_inProgressFreeBytes > 0 && decumulator.MoveNext()) { BaseReference current = decumulator.Current; decumulator.RemoveCurrent(); if (current.Item != null) { if (current.PinCount == 0) { UpdateStatsForRemovedItem(current, ref m_inProgressFreeBytes); } WriteItem(current); if (current.PinCount > 0) { EnqueueItem(current); CacheSetValue(current.Id, current); } } } } }
public void Remove(ItemHolder item) { if (m_count == 0) { Global.Tracer.Assert(condition: false, "Cannot ExtractLRU from empty cache"); } m_count--; item.Previous.Next = item.Next; item.Next.Previous = item.Previous; item.Next = null; item.Previous = null; }
public sealed override IReference <T> GenerateFixedReference <T>(T obj) { BaseReference baseReference = CreateReference(obj); baseReference.Init(this, GenerateTempId()); ItemHolder itemHolder = new ItemHolder(); itemHolder.Reference = baseReference; itemHolder.Item = obj; baseReference.Item = itemHolder; baseReference.InQueue = InQueueState.InQueue; return((IReference <T>)baseReference); }
private void CacheItem(BaseReference reference, IStorable item, bool fromDeserialize, int newItemSize) { ItemHolder itemHolder = new ItemHolder(); itemHolder.Reference = reference; itemHolder.Item = item; reference.Item = itemHolder; FreeCacheSpace(newItemSize, m_cacheFreeableBytes); if (fromDeserialize) { CacheSetValue(reference.Id, reference); m_cacheFreeableBytes += newItemSize; } else { m_totalAuditedBytes += newItemSize; } m_cacheSizeBytes += newItemSize; EnqueueItem(reference); }
internal sealed override void UnPin(BaseReference reference) { if (reference.PinCount == 0 && (reference.Id.IsTemporary || reference.Id.HasMultiPart) && reference.InQueue == InQueueState.None) { reference.InQueue = InQueueState.InQueue; m_serializationQueue.Enqueue(reference); if (!m_lockedDownForFlush) { ItemHolder item = reference.Item; IStorable obj = null; if (item != null) { obj = item.Item; } m_cacheFreeableBytes += ItemSizes.SizeOf(obj); } } if (!m_lockedDownForFlush) { PeriodicOperationCheck(); } }
public LinkedLRUCache() { m_sentinal = new ItemHolder(); Clear(); }