/// <inheritdoc /> public void MergeAtSubprogram(Snapshot snapshot, List <Snapshot> snapshots, ProgramPointBase[] extendedPoints) { TrackingMergeStructureWorker structureWorker = new TrackingMergeStructureWorker(Factories, snapshot, snapshots); structureWorker.MergeStructure(); ISnapshotStructureProxy structure = structureWorker.Structure; TrackingMergeDataWorker dataWorker = new TrackingMergeDataWorker(Factories, snapshot, structure.Readonly, snapshots); dataWorker.MergeData(); ISnapshotDataProxy data = dataWorker.Data; int localLevel = structure.Readonly.CallLevel; var structureTracker = structure.Writeable.WriteableChangeTracker; structureTracker.SetCallLevel(localLevel); structureTracker.SetConnectionType(TrackerConnectionType.SUBPROGRAM_MERGE); var dataTracker = data.Writeable.WriteableChangeTracker; dataTracker.SetCallLevel(localLevel); dataTracker.SetConnectionType(TrackerConnectionType.SUBPROGRAM_MERGE); for (int x = 0; x < snapshots.Count; x++) { Snapshot callSnapshot = (Snapshot)extendedPoints[x].OutSet.Snapshot; Snapshot mergeAncestor = snapshots[x]; structureTracker.AddCallTracker(callSnapshot, mergeAncestor.Structure.Readonly.ReadonlyChangeTracker); dataTracker.AddCallTracker(callSnapshot, mergeAncestor.Data.Readonly.ReadonlyChangeTracker); } snapshot.SetMemoryMergeResult(localLevel, structure, data); }
/// <summary> /// Initializes a new instance of the <see cref="ModularMemoryModelFactories" /> class. /// </summary> /// <param name="snapshotStructureFactory">The snapshot structure factory.</param> /// <param name="structuralContainersFactories">The structural containers factories.</param> /// <param name="snapshotDataFactory">The snapshot data factory.</param> /// <param name="memoryAlgorithmFactories">The memory algorithm factories.</param> /// <param name="infoAlgorithmFactories">The information algorithm factories.</param> /// <param name="benchmark">The benchmark.</param> /// <param name="logger">The logger.</param> internal ModularMemoryModelFactories( ISnapshotStructureFactory snapshotStructureFactory, StructuralContainersFactories structuralContainersFactories, ISnapshotDataFactory snapshotDataFactory, AlgorithmFactories memoryAlgorithmFactories, AlgorithmFactories infoAlgorithmFactories, IBenchmark benchmark, ILogger logger ) { SnapshotStructureFactory = snapshotStructureFactory; StructuralContainersFactories = structuralContainersFactories; SnapshotDataFactory = snapshotDataFactory; MemoryAlgorithmFactories = memoryAlgorithmFactories; InfoAlgorithmFactories = infoAlgorithmFactories; Benchmark = benchmark; Logger = logger; MemoryAlgorithms = memoryAlgorithmFactories.CreateInstances(this); InfoAlgorithms = infoAlgorithmFactories.CreateInstances(this); MemoryModelSnapshotFactory = new ModularMemoryModelSnapshotFactory(this); InitialSnapshotStructureInstance = SnapshotStructureFactory.CreateGlobalContextInstance(this); InitialSnapshotDataInstance = SnapshotDataFactory.CreateEmptyInstance(this); InitialSnapshotInfoInstance = SnapshotDataFactory.CreateEmptyInstance(this); }
/// <inheritdoc /> public void Extend(Snapshot extendedSnapshot, Snapshot sourceSnapshot) { ISnapshotStructureProxy structure = Factories.SnapshotStructureFactory.CopyInstance(sourceSnapshot.Structure); ISnapshotDataProxy data = Factories.SnapshotDataFactory.CopyInstance(sourceSnapshot.Data); extendedSnapshot.SetMemoryMergeResult(sourceSnapshot.CallLevel, structure, data); }
/// <inheritdoc /> public void Extend(Snapshot extendedSnapshot, Snapshot sourceSnapshot) { ISnapshotDataProxy data = Factories.SnapshotDataFactory.CopyInstance(sourceSnapshot.Infos); extendedSnapshot.AssignCreatedAliases(extendedSnapshot, data); extendedSnapshot.SetInfoMergeResult(data); }
/// <inheritdoc /> public void ExtendAsCall(Snapshot extendedSnapshot, Snapshot sourceSnapshot, ProgramPointGraph calleeProgramPoint, MemoryEntry thisObject) { ISnapshotDataProxy data = Factories.SnapshotDataFactory.CopyInstance(sourceSnapshot.Infos); data.Writeable.WriteableChangeTracker.SetCallLevel(extendedSnapshot.CallLevel); data.Writeable.WriteableChangeTracker.SetConnectionType(TrackerConnectionType.CALL_EXTEND); extendedSnapshot.SetInfoMergeResult(data); }
/// <inheritdoc /> public void ExtendAsCall(Snapshot extendedSnapshot, Snapshot sourceSnapshot, ProgramPointGraph calleeProgramPoint, MemoryEntry thisObject) { ISnapshotStructureProxy structure = Factories.SnapshotStructureFactory.CopyInstance(sourceSnapshot.Structure); ISnapshotDataProxy data = Factories.SnapshotDataFactory.CopyInstance(sourceSnapshot.Data); int localLevel = sourceSnapshot.CallLevel + 1; structure.Writeable.AddLocalLevel(); extendedSnapshot.SetMemoryMergeResult(localLevel, structure, data); }
/// <inheritdoc /> public void MergeWithCall(Snapshot snapshot, Snapshot callSnapshot, List <Snapshot> snapshots) { int localLevel = callSnapshot.CallLevel; MergeInfoWorker worker = new MergeInfoWorker(Factories, snapshot, snapshots, localLevel, true); worker.Merge(); ISnapshotDataProxy data = worker.Infos; snapshot.SetInfoMergeResult(data); }
/// <inheritdoc /> public void Merge(Snapshot snapshot, List <Snapshot> snapshots) { int localLevel = findMaxCallLevel(snapshots); MergeInfoWorker worker = new MergeInfoWorker(Factories, snapshot, snapshots, localLevel); worker.Merge(); ISnapshotDataProxy data = worker.Infos; snapshot.SetInfoMergeResult(data); }
/// <summary> /// Initializes a new instance of the <see cref="MergeInfoWorker" /> class. /// </summary> /// <param name="factories">The factories.</param> /// <param name="targetSnapshot">The target snapshot.</param> /// <param name="sourceSnapshots">The source snapshots.</param> /// <param name="targetCallLevel">The target call level.</param> /// <param name="isCallMerge">if set to <c>true</c> [is call merge].</param> public MergeInfoWorker(ModularMemoryModelFactories factories, Snapshot targetSnapshot, List <Snapshot> sourceSnapshots, int targetCallLevel, bool isCallMerge = false) { Factories = factories; Infos = Factories.SnapshotDataFactory.CreateEmptyInstance(Factories); Structure = targetSnapshot.Structure; Structure.Locked = true; this.targetSnapshot = targetSnapshot; this.sourceSnapshots = sourceSnapshots; this.isCallMerge = isCallMerge; this.targetCallLevel = targetCallLevel; }
/// <inheritdoc /> public void MergeWithCall(Snapshot snapshot, Snapshot callSnapshot, List <Snapshot> snapshots) { int localLevel = callSnapshot.CallLevel; MergeWorker worker = new MergeWorker(Factories, snapshot, snapshots, localLevel, true); worker.Merge(); ISnapshotStructureProxy structure = worker.Structure; ISnapshotDataProxy data = worker.Data; snapshot.SetMemoryMergeResult(localLevel, structure, data); }
/// <summary> /// Initializes a new instance of the <see cref="MergeWorker" /> class. /// </summary> /// <param name="factories">The factories.</param> /// <param name="targetSnapshot">The target snapshot.</param> /// <param name="sourceSnapshots">The source snapshots.</param> /// <param name="targetCallLevel">The target call level.</param> /// <param name="isCallMerge">if set to <c>true</c> [is call merge].</param> public MergeWorker(ModularMemoryModelFactories factories, Snapshot targetSnapshot, List <Snapshot> sourceSnapshots, int targetCallLevel, bool isCallMerge = false) { Factories = factories; Data = Factories.SnapshotDataFactory.CreateEmptyInstance(Factories); Structure = Factories.SnapshotStructureFactory.CreateEmptyInstance(Factories); this.targetSnapshot = targetSnapshot; this.sourceSnapshots = sourceSnapshots; this.isCallMerge = isCallMerge; this.writeableStrucure = Structure.Writeable; this.targetSnapshotCallLevel = targetCallLevel; }
/// <summary> /// Converts the specified proxy to CopySnapshotDataProxy type. /// </summary> /// <param name="proxy">The proxy.</param> /// <returns>Casted object to CopySnapshotDataProxy type.</returns> /// <exception cref="System.InvalidCastException">Argument is not of type CopySnapshotDataProxy</exception> public static TrackingSnapshotDataProxy Convert(ISnapshotDataProxy proxy) { TrackingSnapshotDataProxy converted = proxy as TrackingSnapshotDataProxy; if (converted != null) { return(converted); } else { throw new InvalidCastException("Argument is not of type CopySnapshotDataProxy"); } }
/// <inheritdoc /> public void Merge(Snapshot snapshot, List <Snapshot> snapshots) { TrackingMergeDataWorker dataWorker = new TrackingMergeDataWorker(Factories, snapshot, snapshot.Structure.Readonly, snapshots); dataWorker.MergeInfo(); ISnapshotDataProxy data = dataWorker.Data; int localLevel = snapshot.Structure.Readonly.CallLevel; data.Writeable.WriteableChangeTracker.SetCallLevel(localLevel); data.Writeable.WriteableChangeTracker.SetConnectionType(TrackerConnectionType.MERGE); snapshot.SetInfoMergeResult(data); }
/// <summary> /// Initializes a new instance of the <see cref="CopyCommitWorker"/> class. /// </summary> /// <param name="factories">The factories.</param> /// <param name="snapshot">The snapshot.</param> /// <param name="simplifyLimit">The simplify limit.</param> /// <param name="newStructure">The new structure.</param> /// <param name="oldStructure">The old structure.</param> /// <param name="newData">The new data.</param> /// <param name="oldData">The old data.</param> public CopyCommitWorker(ModularMemoryModelFactories factories, Snapshot snapshot, int simplifyLimit, ISnapshotStructureProxy newStructure, ISnapshotStructureProxy oldStructure, ISnapshotDataProxy newData, ISnapshotDataProxy oldData) { Factories = factories; this.snapshot = snapshot; this.simplifyLimit = simplifyLimit; this.assistant = snapshot.MemoryAssistant; this.newStructure = newStructure; this.oldStructure = oldStructure; this.newData = newData; this.oldData = oldData; }
/// <inheritdoc /> public void ExtendAsCall(Snapshot extendedSnapshot, Snapshot sourceSnapshot, ProgramPointGraph calleeProgramPoint, MemoryEntry thisObject) { int localLevel = calleeProgramPoint.ProgramPointGraphID; ISnapshotStructureProxy structure = Factories.SnapshotStructureFactory.CopyInstance(sourceSnapshot.Structure); if (!structure.Writeable.ContainsStackWithLevel(localLevel)) { structure.Writeable.AddStackLevel(localLevel); } structure.Writeable.SetLocalStackLevelNumber(localLevel); structure.Writeable.WriteableChangeTracker.SetCallLevel(localLevel); structure.Writeable.WriteableChangeTracker.SetConnectionType(TrackerConnectionType.CALL_EXTEND); ISnapshotDataProxy data = Factories.SnapshotDataFactory.CopyInstance(sourceSnapshot.Data); data.Writeable.WriteableChangeTracker.SetCallLevel(localLevel); data.Writeable.WriteableChangeTracker.SetConnectionType(TrackerConnectionType.CALL_EXTEND); extendedSnapshot.SetMemoryMergeResult(localLevel, structure, data); }
/// <inheritdoc /> public void MergeWithCall(Snapshot snapshot, Snapshot callSnapshot, List <Snapshot> snapshots) { TrackingMergeStructureWorker structureWorker = new TrackingMergeStructureWorker(Factories, snapshot, snapshots); structureWorker.CallMergeStructure(callSnapshot); ISnapshotStructureProxy structure = structureWorker.Structure; TrackingMergeDataWorker dataWorker = new TrackingMergeDataWorker(Factories, snapshot, structure.Readonly, snapshots); dataWorker.MergeCallData(callSnapshot); ISnapshotDataProxy data = dataWorker.Data; int localLevel = structure.Readonly.CallLevel; structure.Writeable.WriteableChangeTracker.SetCallLevel(localLevel); structure.Writeable.WriteableChangeTracker.SetConnectionType(TrackerConnectionType.CALL_MERGE); data.Writeable.WriteableChangeTracker.SetCallLevel(localLevel); data.Writeable.WriteableChangeTracker.SetConnectionType(TrackerConnectionType.CALL_MERGE); snapshot.SetMemoryMergeResult(localLevel, structure, data); }
/// <inheritdoc /> public void ExtendAsCall(Snapshot extendedSnapshot, Snapshot sourceSnapshot, ProgramPointGraph calleeProgramPoint, MemoryEntry thisObject) { ISnapshotDataProxy data = Factories.SnapshotDataFactory.CopyInstance(sourceSnapshot.Infos); extendedSnapshot.SetInfoMergeResult(data); }
/// <inheritdoc /> public ISnapshotDataProxy CopyInstance(ISnapshotDataProxy oldData) { TrackingSnapshotDataProxy proxy = TrackingSnapshotDataProxy.Convert(oldData); return(new TrackingSnapshotDataProxy(proxy)); }
/// <summary> /// Creates the new data. /// </summary> private void createNewData() { Data = Factories.SnapshotDataFactory.CopyInstance(callSnapshot.Data); writeableTargetData = Data.Writeable; }
/// <inheritdoc /> public ISnapshotDataProxy CopyInstance(ISnapshotDataProxy oldData) { CopySnapshotDataProxy proxy = CopySnapshotDataProxy.Convert(oldData); return(new CopySnapshotDataProxy(proxy)); }