/// <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));
}
