private StorageItem LoadItem(BaseReference reference) { if (base.m_inStreamOper) { Global.Tracer.Assert(false, "ScalabilityCache should not Load during serialization"); } StorageItem storageItem = null; try { base.m_inStreamOper = true; base.m_deserializationTimer.Start(); long num = this.m_offsetMap.Retrieve(reference.Id); if (num >= 0) { long persistedSize = default(long); storageItem = (StorageItem)base.m_storage.Retrieve(num, out persistedSize); storageItem.Offset = num; storageItem.PersistedSize = persistedSize; storageItem.UpdateSize(); storageItem.HasBeenUnPinned = true; } else { Global.Tracer.Assert(false); } } finally { base.m_inStreamOper = false; base.m_deserializationTimer.Stop(); } this.CacheItem(reference, storageItem, true); return(storageItem); }
private void CacheItem(BaseReference reference, StorageItem item, bool fromDeserialize) { reference.Item = item; item.AddReference(reference); int num = ItemSizes.SizeOf(item); base.FreeCacheSpace(num, base.m_cacheSizeBytes); if (fromDeserialize) { this.CacheSetValue(reference.Id, item); } else { base.m_totalAuditedBytes += num; } base.m_cacheSizeBytes += num; this.EnqueueItem(item); object item2 = item.Item; ISelfReferential selfReferential = item2 as ISelfReferential; if (selfReferential != null) { selfReferential.SetReference(reference); } }
private void EnqueueItem(BaseReference itemRef) { AspNetCore.ReportingServices.ReportIntermediateFormat.Persistence.ObjectType objectType = itemRef.GetObjectType(); if (objectType == AspNetCore.ReportingServices.ReportIntermediateFormat.Persistence.ObjectType.SubReportInstanceReference) { if (this.m_pinnedItems == null) { this.m_pinnedItems = new LinkedBucketedQueue <BaseReference>(25); } this.m_pinnedItems.Enqueue(itemRef); } else { ReferenceID id = itemRef.Id; if (!id.IsTemporary) { if (id.HasMultiPart && this.m_partitionManager.GetTreePartitionOffset(id) == TreePartitionManager.EmptyTreePartitionOffset) { return; } this.m_cachePriority.Add(itemRef.Item); itemRef.InQueue = InQueueState.Exempt; } } }
public override void Pin(BaseReference reference) { StorageItem storageItem = (StorageItem)reference.Item; if (storageItem == null) { if (this.CacheTryGetValue(reference.Id, out storageItem)) { reference.Item = storageItem; storageItem.AddReference(reference); if (storageItem.InQueue == InQueueState.InQueue) { this.m_cachePriority.Bump(storageItem); } } else { storageItem = this.LoadItem(reference); } } else if (storageItem.InQueue == InQueueState.InQueue) { this.m_cachePriority.Bump(storageItem); } storageItem.PinCount++; }
public override void Free(BaseReference reference) { if (!(reference == (object)null)) { ReferenceID id = reference.Id; StorageItem storageItem = default(StorageItem); if (this.CacheTryGetValue(id, out storageItem)) { this.CacheRemoveValue(id); } if (storageItem == null) { storageItem = (StorageItem)reference.Item; } if (storageItem != null) { if (storageItem.InQueue == InQueueState.InQueue) { this.m_cachePriority.Remove(storageItem); } int num = ItemSizes.SizeOf(storageItem); base.m_cacheSizeBytes -= num; base.m_totalAuditedBytes -= num; base.m_totalFreedBytes += num; base.UpdatePeakCacheSize(); storageItem.Item = null; storageItem.UnlinkReferences(false); } reference.Item = null; } }
private void WriteItem(BaseReference itemRef) { ItemHolder item = itemRef.Item; IStorable item2 = item.Item; ReferenceID id = itemRef.Id; long num = base.m_storage.Allocate(item2); if (id.HasMultiPart && !id.IsTemporary) { this.m_partitionManager.UpdateTreePartitionOffset(id, num); if (itemRef.PinCount == 0) { this.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 UnlinkReferences(bool updateId) { if (base.Reference != (object)null) { if (updateId) { base.Reference.Id = this.Id; } base.Reference.Item = null; } if (this.m_otherReferences != null) { while (this.m_otherReferences.Count > 0) { BaseReference baseReference = this.m_otherReferences.Dequeue(); baseReference.Item = null; if (updateId) { baseReference.Id = this.Id; } } } base.Reference = null; this.m_otherReferences = null; }
public sealed override void ReferenceValueCallback(BaseReference reference) { if (reference.InQueue == InQueueState.Exempt) { this.m_cachePriority.Bump(reference.Item); } base.ReferenceValueCallback(reference); }
public override void UpdateTargetSize(BaseReference reference, int sizeDeltaBytes) { StorageItem storageItem = (StorageItem)reference.Item; storageItem.UpdateSize(sizeDeltaBytes); base.m_cacheSizeBytes += sizeDeltaBytes; base.m_totalAuditedBytes += sizeDeltaBytes; }
public void CacheSetValue(ReferenceID id, BaseReference value) { if (this.m_cacheLookup == null) { this.m_cacheLookup = new SegmentedDictionary <ReferenceID, BaseReference>(503, 17, ReferenceIDEqualityComparer.Instance); } this.m_cacheLookup[id] = value; }
public void SetTreePartitionContentsAndPin <T>(IReference <T> emptyPartitionRef, T contents) where T : IStorable { BaseReference baseReference = (BaseReference)emptyPartitionRef; this.m_partitionManager.TreeHasChanged = true; this.CacheItem(baseReference, (IStorable)(object)contents, false, ItemSizes.SizeOf((IStorable)(object)contents)); baseReference.PinValue(); this.CacheSetValue(baseReference.Id, baseReference); }
public sealed override void UpdateTargetSize(BaseReference reference, int sizeDeltaBytes) { base.m_cacheSizeBytes += sizeDeltaBytes; base.m_totalAuditedBytes += sizeDeltaBytes; if (!reference.Id.IsTemporary) { this.m_cacheFreeableBytes += sizeDeltaBytes; } }
protected BaseReference AllocateAndPin(IStorable obj, int initialSize) { Global.Tracer.Assert(obj != null, "Cannot allocate reference to null"); BaseReference baseReference = base.CreateReference(obj); baseReference.Init(this, this.GenerateTempId()); this.CacheItem(baseReference, obj, false, initialSize); baseReference.PinValue(); return(baseReference); }
protected BaseReference CreateReference(IStorable storable) { BaseReference result = default(BaseReference); if (!this.m_referenceCreator.TryCreateReference(storable, out result)) { Global.Tracer.Assert(false, "Cannot create reference to: {0}", storable); } return(result); }
public sealed override IReference PoolReference(IReference reference) { BaseReference baseReference = default(BaseReference); if (this.CacheTryGetValue(reference.Id, out baseReference)) { reference = baseReference; } return(reference); }
public bool CacheTryGetValue(ReferenceID id, out BaseReference item) { item = null; bool result = false; if (this.m_cacheLookup != null) { result = this.m_cacheLookup.TryGetValue(id, out item); } return(result); }
public override IStorable Retrieve(BaseReference reference) { StorageItem storageItem = default(StorageItem); if (!this.CacheTryGetValue(reference.Id, out storageItem)) { storageItem = this.LoadItem(reference); } base.PeriodicOperationCheck(); return(storageItem.Item); }
public IReference <T> AllocateEmptyTreePartition <T>(AspNetCore.ReportingServices.ReportIntermediateFormat.Persistence.ObjectType referenceObjectType) { BaseReference baseReference = default(BaseReference); if (!base.m_referenceCreator.TryCreateReference(referenceObjectType, out baseReference)) { Global.Tracer.Assert(false, "Cannot create reference of type: {0}", referenceObjectType); } baseReference.Init(this, this.m_partitionManager.AllocateNewTreePartition()); return((IReference <T>)baseReference); }
public bool TryCreateReference(IStorable refTarget, out BaseReference newReference) { AspNetCore.ReportingServices.ReportIntermediateFormat.Persistence.ObjectType objectType = refTarget.GetObjectType(); AspNetCore.ReportingServices.ReportIntermediateFormat.Persistence.ObjectType referenceObjectType = default(AspNetCore.ReportingServices.ReportIntermediateFormat.Persistence.ObjectType); if (this.TryMapObjectTypeToReferenceType(objectType, out referenceObjectType)) { return(this.TryCreateReference(referenceObjectType, out newReference)); } newReference = null; return(false); }
protected sealed override void FulfillInProgressFree() { int num = this.m_cachePriority.Count; while (base.m_inProgressFreeBytes > 0 && num > 0) { num--; ItemHolder itemHolder = this.m_cachePriority.Peek(); BaseReference reference = itemHolder.Reference; if (reference.PinCount == 0) { this.m_cachePriority.ExtractLRU(); reference.InQueue = InQueueState.None; if (itemHolder.Item != null) { this.UpdateStatsForRemovedItem(reference, ref base.m_inProgressFreeBytes); this.CacheRemoveValue(reference.Id); itemHolder.Item = null; itemHolder.Reference = null; reference.Item = null; } } else { this.m_cachePriority.Bump(itemHolder); } } if (base.m_inProgressFreeBytes > 0) { using (IDecumulator <BaseReference> decumulator = this.m_serializationQueue.GetDecumulator()) { while (base.m_inProgressFreeBytes > 0 && decumulator.MoveNext()) { BaseReference current = decumulator.Current; decumulator.RemoveCurrent(); if (current.Item != null) { if (current.PinCount == 0) { this.UpdateStatsForRemovedItem(current, ref base.m_inProgressFreeBytes); } this.WriteItem(current); if (current.PinCount > 0) { this.EnqueueItem(current); this.CacheSetValue(current.Id, current); } } } } } }
public sealed override IReference <T> GenerateFixedReference <T>(T obj) { BaseReference baseReference = base.CreateReference((IStorable)(object)obj); baseReference.Init(this, this.GenerateTempId()); ItemHolder itemHolder = new ItemHolder(); itemHolder.Reference = baseReference; itemHolder.Item = (IStorable)(object)obj; baseReference.Item = itemHolder; baseReference.InQueue = InQueueState.InQueue; return((IReference <T>)baseReference); }
private IReference <T> InternalAllocate <T>(T obj, int priority, bool startPinned, int initialSize) where T : IStorable { Global.Tracer.Assert(obj != null, "Cannot allocate reference to null"); BaseReference baseReference = base.CreateReference((IStorable)(object)obj); baseReference.Init(this, this.m_offsetMap.GenerateTempId()); this.CacheItem(baseReference, (IStorable)(object)obj, priority, initialSize); if (startPinned) { baseReference.PinValue(); } return((IReference <T>)baseReference); }
public override bool Equals(object obj) { if (object.ReferenceEquals(obj, null)) { return(false); } BaseReference baseReference = obj as BaseReference; if (baseReference == (object)null) { return(false); } return(this.m_id == baseReference.m_id); }
private static List <Declaration> BuildDeclarations() { List <Declaration> list = new List <Declaration>(8); list.Add(BaseReference.GetDeclaration()); list.Add(ScalableList <StorageItem> .GetDeclaration()); list.Add(ScalableDictionary <int, StorageItem> .GetDeclaration()); list.Add(ScalableDictionaryNode.GetDeclaration()); list.Add(ScalableDictionaryValues.GetDeclaration()); list.Add(StorageItem.GetDeclaration()); list.Add(StorableArray.GetDeclaration()); list.Add(ScalableHybridListEntry.GetDeclaration()); return(list); }
public bool TryCreateReference(IStorable refTarget, out BaseReference newReference) { switch (refTarget.GetObjectType()) { case AspNetCore.ReportingServices.ReportIntermediateFormat.Persistence.ObjectType.StorableArray: return(this.TryCreateReference(AspNetCore.ReportingServices.ReportIntermediateFormat.Persistence.ObjectType.StorableArrayReference, out newReference)); case AspNetCore.ReportingServices.ReportIntermediateFormat.Persistence.ObjectType.ScalableDictionaryNode: return(this.TryCreateReference(AspNetCore.ReportingServices.ReportIntermediateFormat.Persistence.ObjectType.ScalableDictionaryNodeReference, out newReference)); default: newReference = null; return(false); } }
public void AddReference(BaseReference newReference) { if (base.Reference == (object)null) { base.Reference = newReference; } else { if (this.m_otherReferences == null) { this.m_otherReferences = new LinkedBucketedQueue <BaseReference>(5); } this.m_otherReferences.Enqueue(newReference); } }
public bool TryCreateReference(ObjectType referenceObjectType, out BaseReference newReference) { bool flag = false; newReference = null; for (int i = 0; i < this.m_referenceCreators.Length; i++) { if (flag) { break; } flag = this.m_referenceCreators[i].TryCreateReference(referenceObjectType, out newReference); } return(flag); }
public override void ReferenceSerializeCallback(BaseReference reference) { ReferenceID id = reference.Id; if (id.IsTemporary) { StorageItem storageItem = (StorageItem)reference.Item; ReferenceID referenceID = this.m_offsetMap.GenerateId(id); if (id != referenceID) { reference.Id = referenceID; storageItem.Id = referenceID; this.CacheRemoveValue(id); } this.CacheSetValue(reference.Id, storageItem); } }
private void UpdateStatsForRemovedItem(BaseReference itemRef, ref long bytesToFree) { long num = ItemSizes.SizeOf(itemRef.Item.Item); long num2 = base.m_cacheSizeBytes - num; long num3 = this.m_cacheFreeableBytes - num; if (num3 < 0) { num3 = 0L; } if (num2 < num3) { num2 = num3; } this.m_cacheFreeableBytes = num3; base.m_cacheSizeBytes = num2; bytesToFree -= num; }
public override IReference <T> GenerateFixedReference <T>(T obj) { BaseReference baseReference = base.CreateReference((IStorable)(object)obj); baseReference.Init(this, this.m_offsetMap.GenerateTempId()); StorageItem storageItem = (StorageItem)(baseReference.Item = new StorageItem(baseReference.Id, -1, (IStorable)(object)obj, ItemSizes.SizeOf((IStorable)(object)obj))); storageItem.AddReference(baseReference); storageItem.InQueue = InQueueState.Exempt; storageItem.HasBeenUnPinned = true; ISelfReferential selfReferential = ((object)obj) as ISelfReferential; if (selfReferential != null) { selfReferential.SetReference(baseReference); } return((IReference <T>)baseReference); }