/// <summary>
/// Creates the structure with memory stack with global level only.
/// </summary>
/// <param name="factories">The factories.</param>
/// <returns>
/// New structure with memory stack with global level only.
/// </returns>
public static CopySnapshotStructureProxy CreateGlobal(ModularMemoryModelFactories factories)
{
CopySnapshotStructureProxy proxy = new CopySnapshotStructureProxy();
proxy.snapshotStructure = SnapshotStructureContainer.CreateGlobal(factories);
return(proxy);
}
/// <summary>
/// Initializes a new instance of the <see cref="TrackingCallMergeStructureWorker"/> class.
/// </summary>
/// <param name="factories">The factories.</param>
/// <param name="targetSnapshot">The target snapshot.</param>
/// <param name="callSnapshot">The call snapshot.</param>
/// <param name="sourceSnapshots">The source snapshots.</param>
public TrackingCallMergeStructureWorker(ModularMemoryModelFactories factories, Snapshot targetSnapshot, Snapshot callSnapshot, List <Snapshot> sourceSnapshots)
: base(factories, targetSnapshot, sourceSnapshots, true)
{
this.callSnapshot = callSnapshot;
MemoryAliases = new Dictionary <MemoryIndex, MemoryAliasInfo>();
Factories = factories;
}
/// <summary>
/// Creates empty structure which contains no data in containers.
/// </summary>
/// <param name="factories">The factories.</param>
/// <returns>
/// New empty structure which contains no data in containers.
/// </returns>
public static LazyCopySnapshotStructureProxy CreateEmpty(ModularMemoryModelFactories factories)
{
LazyCopySnapshotStructureProxy proxy = new LazyCopySnapshotStructureProxy(factories);
proxy.snapshotStructure = SnapshotStructureContainer.CreateEmpty(factories);
proxy.readonlyInstance = proxy.snapshotStructure;
proxy.isReadonly = false;
return proxy;
}
/// <summary>
/// Initializes a new instance of the <see cref="AbstractTrackingMergeWorker"/> class.
/// </summary>
/// <param name="factories">The factories.</param>
/// <param name="targetSnapshot">The target snapshot.</param>
/// <param name="sourceSnapshots">The source snapshots.</param>
/// <param name="isCallMerge">if set to <c>true</c> [is call merge].</param>
public AbstractTrackingMergeWorker(ModularMemoryModelFactories factories, Snapshot targetSnapshot, List <Snapshot> sourceSnapshots, bool isCallMerge = false)
{
Factories = factories;
this.targetSnapshot = targetSnapshot;
this.sourceSnapshots = sourceSnapshots;
this.isCallMerge = isCallMerge;
}
/// <summary>
/// Initializes a new instance of the <see cref="AssignWorker"/> class.
/// </summary>
/// <param name="factories">The factories.</param>
/// <param name="snapshot">The snapshot.</param>
/// <param name="memoryEntryCollector">The memory entry collector.</param>
/// <param name="treeCollector">The tree collector.</param>
/// <param name="pathModifications">The path modifications.</param>
public AssignWorker(ModularMemoryModelFactories factories, Snapshot snapshot, MemoryEntryCollector memoryEntryCollector,
TreeIndexCollector treeCollector, MemoryIndexModificationList pathModifications)
: base(factories, snapshot, treeCollector, pathModifications)
{
this.memoryEntryCollector = memoryEntryCollector;
ForceStrongWrite = false;
AssignAliasesIntoCollectedIndexes = false;
}
/// <summary>
/// Creates empty structure which contains no data in containers.
/// </summary>
/// <param name="factories">The factories.</param>
/// <returns>
/// New empty structure which contains no data in containers.
/// </returns>
public static TrackingSnapshotStructureProxy CreateEmpty(ModularMemoryModelFactories factories)
{
TrackingSnapshotStructureProxy proxy = new TrackingSnapshotStructureProxy(factories);
proxy.snapshotStructure = TrackingSnapshotStructureContainer.CreateEmpty(factories);
proxy.readonlyInstance = proxy.snapshotStructure;
proxy.isReadonly = false;
return(proxy);
}
/// <summary>
/// Starts the benchmark.
/// </summary>
/// <param name="numberOfRepetitions">The number of repetitions.</param>
public void StartBenchmark(int numberOfRepetitions)
{
this.memoryModelBenchmark = new MemoryModelBenchmark();
var builder = selectMemoryModel().Builder();
builder.Benchmark = this.memoryModelBenchmark;
ModularMemoryModelFactories factories = builder.Build();
MemoryModel = factories.MemoryModelSnapshotFactory;
WatchFirstPhase = new Stopwatch();
WatchSecondPhase = new Stopwatch();
RepetitionCounter = 1;
initialiseAnalysisSingletons();
Watch = Stopwatch.StartNew();
try
{
createControlFlowGraph();
while (RepetitionCounter <= numberOfRepetitions)
{
clearComputation();
BenchmarkResult result = new BenchmarkResult();
benchmarkResults.Add(result);
result.StartBenchmarking();
runFirstPhaseAnalysis();
runSecondPhaseAnalysis();
result.StopBenchmarking(this.memoryModelBenchmark);
this.memoryModelBenchmark.ClearResults();
RepetitionCounter++;
}
EndState = AnalysisEndState.Success;
}
catch (ThreadAbortException e)
{
EndState = (AnalysisEndState)e.ExceptionState;
}
catch (Exception e)
{
AnalysisException = e;
EndState = AnalysisEndState.Crash;
}
finally
{
Watch.Stop();
IsFinished = true;
}
}
/// <summary>
/// Creates the instances of the algorithms using the factories stored in this container.
/// </summary>
/// <param name="factories">The factories object which will be sent to the instances.</param>
/// <returns>New object with algorithm instances instances.</returns>
public AlgorithmInstances CreateInstances(ModularMemoryModelFactories factories)
{
return(new AlgorithmInstances(
AssignAlgorithmFactory.CreateInstance(factories),
ReadAlgorithmFactory.CreateInstance(factories),
CommitAlgorithmFactory.CreateInstance(factories),
MemoryAlgorithmFactory.CreateInstance(factories),
MergeAlgorithmFactory.CreateInstance(factories),
PrintAlgorithmFactory.CreateInstance(factories)
));
}
/// <summary>
/// Initializes a new instance of the <see cref="AbstractAssignWorker"/> class.
/// </summary>
/// <param name="factories">The factories.</param>
/// <param name="snapshot">The snapshot.</param>
/// <param name="treeCollector">The tree collector.</param>
/// <param name="pathModifications">The path modifications.</param>
public AbstractAssignWorker(ModularMemoryModelFactories factories, Snapshot snapshot,
TreeIndexCollector treeCollector, MemoryIndexModificationList pathModifications)
{
Factories = factories;
this.Snapshot = snapshot;
this.treeCollector = treeCollector;
this.PathModifications = pathModifications;
this.Structure = snapshot.Structure.Writeable;
this.Data = snapshot.CurrentData.Writeable;
}
/// <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;
}
/// <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>
/// Creates the structure with memory stack with global level only.
/// </summary>
/// <param name="factories">The factories.</param>
/// <returns>
/// New structure with memory stack with global level only.
/// </returns>
public static TrackingSnapshotStructureProxy CreateGlobal(ModularMemoryModelFactories factories)
{
TrackingSnapshotStructureProxy proxy = new TrackingSnapshotStructureProxy(factories);
proxy.snapshotStructure = TrackingSnapshotStructureContainer.CreateEmpty(factories);
proxy.isReadonly = false;
proxy.snapshotStructure.AddStackLevel(Snapshot.GLOBAL_CALL_LEVEL);
proxy.snapshotStructure.SetLocalStackLevelNumber(Snapshot.GLOBAL_CALL_LEVEL);
proxy.readonlyInstance = proxy.snapshotStructure;
return(proxy);
}
/// <summary>
/// Initializes a new instance of the <see cref="TrackingMergeStructureWorker"/> class.
/// </summary>
/// <param name="factories">The factories.</param>
/// <param name="targetSnapshot">The target snapshot.</param>
/// <param name="sourceSnapshots">The source snapshots.</param>
public TrackingMergeStructureWorker(ModularMemoryModelFactories factories, Snapshot targetSnapshot, List <Snapshot> sourceSnapshots)
{
MemoryAliases = new Dictionary <MemoryIndex, MemoryAliasInfo>();
Factories = factories;
this.targetSnapshot = targetSnapshot;
this.sourceSnapshots = sourceSnapshots;
if (targetSnapshot.MergeInfo == null)
{
targetSnapshot.MergeInfo = new MergeInfo();
}
}
/// <summary>
/// Initializes a new instance of the <see cref="TrackingMergeDataWorker"/> class.
/// </summary>
/// <param name="factories">The factories.</param>
/// <param name="targetSnapshot">The target snapshot.</param>
/// <param name="targetStructure">The target structure.</param>
/// <param name="sourceSnapshots">The source snapshots.</param>
public TrackingMergeDataWorker(ModularMemoryModelFactories factories, Snapshot targetSnapshot, IReadOnlySnapshotStructure targetStructure, List <Snapshot> sourceSnapshots)
{
this.targetSnapshot = targetSnapshot;
this.sourceSnapshots = sourceSnapshots;
this.targetStructure = targetStructure;
Factories = factories;
if (targetSnapshot.MergeInfo == null)
{
targetSnapshot.MergeInfo = new MergeInfo();
}
}
/// <summary>
/// Creates empty structure which contains no data in containers.
/// </summary>
/// <param name="factories">The factories.</param>
/// <returns>
/// New empty structure which contains no data in containers.
/// </returns>
public static SnapshotStructureContainer CreateEmpty(ModularMemoryModelFactories factories)
{
SnapshotStructureContainer data = new SnapshotStructureContainer(factories);
data.memoryStack = new List <CopyStackContext>();
data.arrayDescriptors = factories.StructuralContainersFactories.AssociativeContainerFactory.CreateWriteableAssociativeContainer <AssociativeArray, IArrayDescriptor>();
data.objectDescriptors = factories.StructuralContainersFactories.AssociativeContainerFactory.CreateWriteableAssociativeContainer <ObjectValue, IObjectDescriptor>();
data.indexDefinitions = factories.StructuralContainersFactories.AssociativeContainerFactory.CreateWriteableAssociativeContainer <MemoryIndex, IIndexDefinition>();
data.functionDecl = factories.StructuralContainersFactories.DeclarationContainerFactory.CreateWriteableDeclarationContainer <FunctionValue>();
data.classDecl = factories.StructuralContainersFactories.DeclarationContainerFactory.CreateWriteableDeclarationContainer <TypeValue>();
data.callArrays = factories.StructuralContainersFactories.AssociativeContainerFactory.CreateWriteableAssociativeContainer <AssociativeArray, CopySet <Snapshot> >();
return(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;
}
public IMergeAlgorithm CreateInstance(ModularMemoryModelFactories factories)
{
return(new TrackingMergeMemoryAlgorithm(factories));
}
/// <inheritdoc />
public ISnapshotDataProxy CreateEmptyInstance(ModularMemoryModelFactories factories)
{
return(new TrackingSnapshotDataProxy(factories));
}
/// <summary>
/// Initializes a new instance of the <see cref="CopySnapshotDataProxy" /> class.
/// </summary>
/// <param name="factories">The factories.</param>
public TrackingSnapshotDataProxy(ModularMemoryModelFactories factories)
{
snapshotData = new TrackingSnapshotDataAssociativeContainer(factories);
isReadonly = false;
readonlyInstance = snapshotData;
}
public LazyCommitInfoAlgorithm(ModularMemoryModelFactories factories)
: base(factories)
{
}
public ICommitAlgorithm CreateInstance(ModularMemoryModelFactories factories)
{
return(new LazyCommitInfoAlgorithm(factories));
}
public PrintAlgorithm(ModularMemoryModelFactories factories)
: base(factories)
{
}
public IMemoryAlgorithm CreateInstance(ModularMemoryModelFactories factories)
{
return(new CopyMemoryAlgorithm(factories));
}
public CopyAssignInfoAlgorithm(ModularMemoryModelFactories factories)
: base(factories)
{
}
public IAssignAlgorithm CreateInstance(ModularMemoryModelFactories factories)
{
return(new CopyAssignInfoAlgorithm(factories));
}
public TrackingMergeMemoryAlgorithm(ModularMemoryModelFactories factories)
: base(factories)
{
}
public IPrintAlgorithm CreateInstance(ModularMemoryModelFactories factories)
{
return(new PrintAlgorithm(factories));
}
public CopyMemoryAlgorithm(ModularMemoryModelFactories factories)
: base(factories)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="TrackingCallMergeDataWorker"/> class.
/// </summary>
/// <param name="factories">The factories.</param>
/// <param name="targetSnapshot">The target snapshot.</param>
/// <param name="callSnapshot">The call snapshot.</param>
/// <param name="sourceSnapshots">The source snapshots.</param>
public TrackingCallMergeDataWorker(ModularMemoryModelFactories factories, Snapshot targetSnapshot, Snapshot callSnapshot, List <Snapshot> sourceSnapshots)
: base(factories, targetSnapshot, sourceSnapshots, true)
{
this.callSnapshot = callSnapshot;
}
/// <summary>
/// Initializes a new instance of the <see cref="AlgorithmBase"/> class.
/// </summary>
/// <param name="factories">The factories.</param>
protected AlgorithmBase(ModularMemoryModelFactories factories)
{
this.Factories = factories;
}
