public static void Transform(LinearTypeChecker linearTypeChecker, MoverTypeChecker moverTypeChecker) { // The order in which originalDecls are computed and then *.AddCheckers are called is // apparently important. The MyDuplicator code currently does not duplicate Attributes. // Consequently, all the yield attributes are eliminated by the AddCheckers code. List <Declaration> originalDecls = new List <Declaration>(); Program program = linearTypeChecker.program; foreach (var decl in program.TopLevelDeclarations) { Procedure proc = decl as Procedure; if (proc != null && QKeyValue.FindBoolAttribute(proc.Attributes, "yields")) { originalDecls.Add(proc); continue; } Implementation impl = decl as Implementation; if (impl != null && QKeyValue.FindBoolAttribute(impl.Proc.Attributes, "yields")) { originalDecls.Add(impl); } } List <Declaration> decls = new List <Declaration>(); OwickiGries.AddCheckers(linearTypeChecker, moverTypeChecker, decls); MoverCheck.AddCheckers(linearTypeChecker, moverTypeChecker, decls); RefinementCheck.AddCheckers(linearTypeChecker, moverTypeChecker, decls); program.TopLevelDeclarations.RemoveAll(x => originalDecls.Contains(x)); program.TopLevelDeclarations.AddRange(decls); }
public static void Transform(LinearTypeChecker linearTypeChecker, MoverTypeChecker moverTypeChecker) { List <Declaration> originalDecls = new List <Declaration>(); Program program = linearTypeChecker.program; foreach (var decl in program.TopLevelDeclarations) { Procedure proc = decl as Procedure; if (proc != null && moverTypeChecker.procToActionInfo.ContainsKey(proc)) { originalDecls.Add(proc); continue; } Implementation impl = decl as Implementation; if (impl != null && moverTypeChecker.procToActionInfo.ContainsKey(impl.Proc)) { originalDecls.Add(impl); } } List <Declaration> decls = new List <Declaration>(); if (!CommandLineOptions.Clo.TrustAtomicityTypes) { MoverCheck.AddCheckers(linearTypeChecker, moverTypeChecker, decls); } OwickiGries.AddCheckers(linearTypeChecker, moverTypeChecker, decls); foreach (Declaration decl in decls) { decl.Attributes = OwickiGries.RemoveYieldsAttribute(decl.Attributes); } program.RemoveTopLevelDeclarations(x => originalDecls.Contains(x)); program.AddTopLevelDeclarations(decls); }
public static void Transform(LinearTypeChecker linearTypeChecker, CivlTypeChecker civlTypeChecker) { Program program = linearTypeChecker.program; // Store the original declarations of yielding procedures, which will be removed after desugaring below. var origProc = program.TopLevelDeclarations.OfType <Procedure>().Where(p => civlTypeChecker.procToYieldingProc.ContainsKey(p)); var origImpl = program.TopLevelDeclarations.OfType <Implementation>().Where(i => civlTypeChecker.procToYieldingProc.ContainsKey(i.Proc)); List <Declaration> originalDecls = Enumerable.Union <Declaration>(origProc, origImpl).ToList(); // Commutativity checks List <Declaration> decls = new List <Declaration>(); if (!CommandLineOptions.Clo.TrustAtomicityTypes) { MoverCheck.AddCheckers(linearTypeChecker, civlTypeChecker, decls); } // Desugaring of yielding procedures YieldingProcChecker.AddCheckers(linearTypeChecker, civlTypeChecker, decls); // Linear type checks LinearTypeChecker.AddCheckers(linearTypeChecker, civlTypeChecker, decls); // Remove original declarations and add new checkers generated above program.RemoveTopLevelDeclarations(x => originalDecls.Contains(x)); program.AddTopLevelDeclarations(decls); civlTypeChecker.SubstituteBackwardAssignments(); foreach (AtomicAction atomicAction in civlTypeChecker.procToAtomicAction.Values) { program.RemoveTopLevelDeclaration(atomicAction.proc); program.RemoveTopLevelDeclaration(atomicAction.impl); } }
public static void Transform(LinearTypeChecker linearTypeChecker, CivlTypeChecker civlTypeChecker) { Program program = linearTypeChecker.program; // Store the original declarations of yielding procedures, which will be removed after desugaring below. var origProc = program.TopLevelDeclarations.OfType <Procedure>().Where(p => civlTypeChecker.procToYieldingProc.ContainsKey(p)); var origImpl = program.TopLevelDeclarations.OfType <Implementation>().Where(i => civlTypeChecker.procToYieldingProc.ContainsKey(i.Proc)); List <Declaration> originalDecls = Enumerable.Union <Declaration>(origProc, origImpl).ToList(); // Commutativity checks List <Declaration> decls = new List <Declaration>(); if (!CommandLineOptions.Clo.TrustAtomicityTypes) { MoverCheck.AddCheckers(linearTypeChecker, civlTypeChecker, decls); } // Desugaring of yielding procedures CivlRefinement.AddCheckers(linearTypeChecker, civlTypeChecker, decls); // Trigger functions for existential vairables in transition relations decls.AddRange(civlTypeChecker.procToAtomicAction.Values.SelectMany(a => a.layerToActionCopy.Values.SelectMany(ac => ac.triggerFuns.Values))); // Remove original declarations and add new checkers generated above program.RemoveTopLevelDeclarations(x => originalDecls.Contains(x)); program.AddTopLevelDeclarations(decls); foreach (AtomicAction atomicAction in civlTypeChecker.procToAtomicAction.Values) { program.RemoveTopLevelDeclaration(atomicAction.proc); program.RemoveTopLevelDeclaration(atomicAction.impl); } }
public static void AddCheckers(LinearTypeChecker linearTypeChecker, CivlTypeChecker civlTypeChecker, List <Declaration> decls) { MoverCheck moverChecking = new MoverCheck(linearTypeChecker, civlTypeChecker, decls); // TODO: make enumeration of mover checks more efficient / elegant var regularMoverChecks = from first in civlTypeChecker.procToAtomicAction.Values from second in civlTypeChecker.procToAtomicAction.Values where first.layerRange.OverlapsWith(second.layerRange) where first.IsRightMover || second.IsLeftMover select new { first, second }; foreach (var moverCheck in regularMoverChecks) { if (moverCheck.first.IsRightMover) { moverChecking.CreateRightMoverCheckers(moverCheck.first, moverCheck.second); } if (moverCheck.second.IsLeftMover) { moverChecking.CreateLeftMoverCheckers(moverCheck.first, moverCheck.second); } } var inductiveSequentializationMoverChecks = from IS in civlTypeChecker.inductiveSequentializations from leftMover in IS.elim.Values from action in civlTypeChecker.procToAtomicAction.Values where action.layerRange.Contains(IS.inputAction.layerRange.upperLayerNum) select new { action, leftMover }; foreach (var moverCheck in inductiveSequentializationMoverChecks) { moverChecking.CreateLeftMoverCheckers(moverCheck.action, moverCheck.leftMover); } // Here we include IS abstractions foreach (var atomicAction in civlTypeChecker.AllAtomicActions.Where(a => a.IsLeftMover)) { moverChecking.CreateNonBlockingChecker(atomicAction); } // IS abstractions are marked left movers, so here we select regular atomic actions // that are not marked left mover but used as abstraction in IS. foreach (var atomicAction in civlTypeChecker.inductiveSequentializations.SelectMany(IS => IS.elim.Values) .Where(a => !a.IsLeftMover).Distinct()) { moverChecking.CreateNonBlockingChecker(atomicAction); } foreach (var introductionAction in civlTypeChecker.procToIntroductionAction.Values) { moverChecking.CreateNonBlockingChecker(introductionAction); } }
public static void AddCheckers(LinearTypeChecker linearTypeChecker, MoverTypeChecker moverTypeChecker, List <Declaration> decls) { if (moverTypeChecker.procToActionInfo.Count == 0) { return; } Dictionary <int, HashSet <ActionInfo> > pools = new Dictionary <int, HashSet <ActionInfo> >(); foreach (ActionInfo action in moverTypeChecker.procToActionInfo.Values) { foreach (int phaseNum in action.callerPhaseNums) { if (!pools.ContainsKey(phaseNum)) { pools[phaseNum] = new HashSet <ActionInfo>(); } pools[phaseNum].Add(action); } } Program program = moverTypeChecker.program; MoverCheck moverChecking = new MoverCheck(linearTypeChecker, moverTypeChecker, decls); foreach (int phaseNum in pools.Keys) { foreach (ActionInfo first in pools[phaseNum]) { Debug.Assert(first.moverType != MoverType.Top); if (first.moverType == MoverType.Atomic) { continue; } foreach (ActionInfo second in pools[phaseNum]) { if (first.IsRightMover) { moverChecking.CreateCommutativityChecker(program, first, second); moverChecking.CreateGatePreservationChecker(program, second, first); } if (first.IsLeftMover) { moverChecking.CreateCommutativityChecker(program, second, first); moverChecking.CreateGatePreservationChecker(program, first, second); moverChecking.CreateFailurePreservationChecker(program, second, first); } } } } }
public static void Transform(CivlTypeChecker civlTypeChecker) { var linearTypeChecker = civlTypeChecker.linearTypeChecker; Program program = linearTypeChecker.program; // Store the original declarations of yielding procedures, which will be removed after desugaring below. var origProc = program.TopLevelDeclarations.OfType <Procedure>() .Where(p => civlTypeChecker.procToYieldingProc.ContainsKey(p)); var origImpl = program.TopLevelDeclarations.OfType <Implementation>() .Where(i => civlTypeChecker.procToYieldingProc.ContainsKey(i.Proc)); List <Declaration> originalDecls = Enumerable.Union <Declaration>(origProc, origImpl).ToList(); // Commutativity checks List <Declaration> decls = new List <Declaration>(); if (!CommandLineOptions.Clo.TrustMoverTypes) { MoverCheck.AddCheckers(civlTypeChecker, decls); } // Desugaring of yielding procedures YieldingProcChecker.AddCheckers(civlTypeChecker, decls); // Linear type checks LinearTypeChecker.AddCheckers(civlTypeChecker, decls); if (!CommandLineOptions.Clo.TrustInductiveSequentialization) { InductiveSequentializationChecker.AddCheckers(civlTypeChecker); } PendingAsyncChecker.AddCheckers(civlTypeChecker); foreach (AtomicAction action in civlTypeChecker.procToAtomicAction.Values.Union(civlTypeChecker .procToIsAbstraction.Values)) { action.AddTriggerAssumes(program); } // Remove original declarations and add new checkers generated above program.RemoveTopLevelDeclarations(x => originalDecls.Contains(x)); program.AddTopLevelDeclarations(decls); BackwardAssignmentSubstituter.SubstituteBackwardAssignments(civlTypeChecker.procToAtomicAction.Values); linearTypeChecker.EraseLinearAnnotations(); }
public static void AddCheckers(LinearTypeChecker linearTypeChecker, MoverTypeChecker moverTypeChecker, List<Declaration> decls) { if (moverTypeChecker.procToActionInfo.Count == 0) return; Dictionary<int, HashSet<ActionInfo>> pools = new Dictionary<int, HashSet<ActionInfo>>(); foreach (ActionInfo action in moverTypeChecker.procToActionInfo.Values) { foreach (int phaseNum in action.callerPhaseNums) { if (!pools.ContainsKey(phaseNum)) { pools[phaseNum] = new HashSet<ActionInfo>(); } pools[phaseNum].Add(action); } } Program program = moverTypeChecker.program; MoverCheck moverChecking = new MoverCheck(linearTypeChecker, moverTypeChecker, decls); foreach (int phaseNum in pools.Keys) { foreach (ActionInfo first in pools[phaseNum]) { Debug.Assert(first.moverType != MoverType.Top); if (first.moverType == MoverType.Atomic) continue; foreach (ActionInfo second in pools[phaseNum]) { if (first.IsRightMover) { moverChecking.CreateCommutativityChecker(program, first, second); moverChecking.CreateGatePreservationChecker(program, second, first); } if (first.IsLeftMover) { moverChecking.CreateCommutativityChecker(program, second, first); moverChecking.CreateGatePreservationChecker(program, first, second); moverChecking.CreateFailurePreservationChecker(program, second, first); } } } } }
public static void AddCheckers(LinearTypeChecker linearTypeChecker, CivlTypeChecker civlTypeChecker, List <Declaration> decls) { if (civlTypeChecker.procToAtomicAction.Count == 0) { return; } MoverCheck moverChecking = new MoverCheck(linearTypeChecker, civlTypeChecker, decls); foreach (int layer in civlTypeChecker.allAtomicActionLayers) { var pool = civlTypeChecker.procToAtomicAction.Values.Where(a => a.layerRange.Contains(layer)); var moverChecks = from first in pool from second in pool where first.moverType != MoverType.Atomic select new { First = first, Second = second }; foreach (var moverCheck in moverChecks) { var first = moverCheck.First.layerToActionCopy[layer]; var second = moverCheck.Second.layerToActionCopy[layer]; if (moverCheck.First.IsRightMover) { moverChecking.CreateCommutativityChecker(first, second); moverChecking.CreateGatePreservationChecker(second, first); } if (moverCheck.First.IsLeftMover) { moverChecking.CreateCommutativityChecker(second, first); moverChecking.CreateGatePreservationChecker(first, second); moverChecking.CreateFailurePreservationChecker(second, first); } } foreach (AtomicAction atomicAction in pool.Where(a => a.IsLeftMover)) { moverChecking.CreateNonBlockingChecker(atomicAction.layerToActionCopy[layer]); } } }
public static void Transform(LinearTypeChecker linearTypeChecker, CivlTypeChecker civlTypeChecker) { List <Declaration> originalDecls = new List <Declaration>(); Program program = linearTypeChecker.program; foreach (var decl in program.TopLevelDeclarations) { Procedure proc = decl as Procedure; if (proc != null && civlTypeChecker.procToActionInfo.ContainsKey(proc)) { originalDecls.Add(proc); continue; } Implementation impl = decl as Implementation; if (impl != null && civlTypeChecker.procToActionInfo.ContainsKey(impl.Proc)) { originalDecls.Add(impl); } } List <Declaration> decls = new List <Declaration>(); if (!CommandLineOptions.Clo.TrustAtomicityTypes) { MoverCheck.AddCheckers(linearTypeChecker, civlTypeChecker, decls); } CivlRefinement.AddCheckers(linearTypeChecker, civlTypeChecker, decls); foreach (AtomicActionInfo info in civlTypeChecker.procToActionInfo.Values.Where(x => x is AtomicActionInfo)) { decls.AddRange(info.triggerFuns.Values); } foreach (Declaration decl in decls) { CivlAttributes.RemoveYieldsAttribute(decl); } program.RemoveTopLevelDeclarations(x => originalDecls.Contains(x)); program.AddTopLevelDeclarations(decls); }
public void TypeCheck() { foreach (Declaration decl in program.TopLevelDeclarations) { Procedure proc = decl as Procedure; if (proc == null) { continue; } foreach (Ensures e in proc.Ensures) { int phaseNum; MoverType moverType = MoverCheck.GetMoverType(e, out phaseNum); if (moverType == MoverType.Top) { continue; } CodeExpr codeExpr = e.Condition as CodeExpr; if (codeExpr == null) { Error(e, "An atomic action must be a CodeExpr"); continue; } if (procToActionInfo.ContainsKey(proc)) { Error(proc, "A procedure can have at most one atomic action"); continue; } procToActionInfo[proc] = new ActionInfo(proc, codeExpr, moverType, phaseNum); } } this.VisitProgram(program); #if QED YieldTypeChecker.PerformYieldTypeChecking(this); #endif }
public static void AddCheckers(LinearTypeChecker linearTypeChecker, CivlTypeChecker civlTypeChecker, List <Declaration> decls) { if (civlTypeChecker.procToActionInfo.Count == 0) { return; } List <ActionInfo> sortedByCreatedLayerNum = new List <ActionInfo>(civlTypeChecker.procToActionInfo.Values.Where(x => x is AtomicActionInfo && !x.isExtern)); sortedByCreatedLayerNum.Sort((x, y) => { return((x.createdAtLayerNum == y.createdAtLayerNum) ? 0 : (x.createdAtLayerNum < y.createdAtLayerNum) ? -1 : 1); }); List <ActionInfo> sortedByAvailableUptoLayerNum = new List <ActionInfo>(civlTypeChecker.procToActionInfo.Values.Where(x => x is AtomicActionInfo && !x.isExtern)); sortedByAvailableUptoLayerNum.Sort((x, y) => { return((x.availableUptoLayerNum == y.availableUptoLayerNum) ? 0 : (x.availableUptoLayerNum < y.availableUptoLayerNum) ? -1 : 1); }); Dictionary <int, HashSet <AtomicActionInfo> > pools = new Dictionary <int, HashSet <AtomicActionInfo> >(); int indexIntoSortedByCreatedLayerNum = 0; int indexIntoSortedByAvailableUptoLayerNum = 0; HashSet <AtomicActionInfo> currPool = new HashSet <AtomicActionInfo>(); while (indexIntoSortedByCreatedLayerNum < sortedByCreatedLayerNum.Count) { var currLayerNum = sortedByCreatedLayerNum[indexIntoSortedByCreatedLayerNum].createdAtLayerNum; pools[currLayerNum] = new HashSet <AtomicActionInfo>(currPool); while (indexIntoSortedByCreatedLayerNum < sortedByCreatedLayerNum.Count) { var actionInfo = sortedByCreatedLayerNum[indexIntoSortedByCreatedLayerNum] as AtomicActionInfo; if (actionInfo.createdAtLayerNum > currLayerNum) { break; } pools[currLayerNum].Add(actionInfo); indexIntoSortedByCreatedLayerNum++; } while (indexIntoSortedByAvailableUptoLayerNum < sortedByAvailableUptoLayerNum.Count) { var actionInfo = sortedByAvailableUptoLayerNum[indexIntoSortedByAvailableUptoLayerNum] as AtomicActionInfo; if (actionInfo.availableUptoLayerNum > currLayerNum) { break; } pools[currLayerNum].Remove(actionInfo); indexIntoSortedByAvailableUptoLayerNum++; } currPool = pools[currLayerNum]; } // No atomic action has mover type Top Debug.Assert(pools.All(l => l.Value.All(a => a.moverType != MoverType.Top))); Program program = civlTypeChecker.program; MoverCheck moverChecking = new MoverCheck(linearTypeChecker, civlTypeChecker, decls); var moverChecks = from layer in pools.Keys from first in pools[layer] from second in pools[layer] where first.moverType != MoverType.Atomic select new { First = first, Second = second }; foreach (var moverCheck in moverChecks) { var first = moverCheck.First; var second = moverCheck.Second; if (first.IsRightMover) { moverChecking.CreateCommutativityChecker(program, first, second); moverChecking.CreateGatePreservationChecker(program, second, first); } if (first.IsLeftMover) { moverChecking.CreateCommutativityChecker(program, second, first); moverChecking.CreateGatePreservationChecker(program, first, second); moverChecking.CreateFailurePreservationChecker(program, second, first); } } foreach (AtomicActionInfo atomicActionInfo in sortedByCreatedLayerNum) { if (atomicActionInfo.IsLeftMover && atomicActionInfo.hasAssumeCmd) { moverChecking.CreateNonBlockingChecker(program, atomicActionInfo); } } }
public static void AddCheckers(LinearTypeChecker linearTypeChecker, MoverTypeChecker moverTypeChecker, List <Declaration> decls) { if (moverTypeChecker.procToActionInfo.Count == 0) { return; } List <ActionInfo> sortedByCreatedLayerNum = new List <ActionInfo>(moverTypeChecker.procToActionInfo.Values.Where(x => x is AtomicActionInfo)); sortedByCreatedLayerNum.Sort((x, y) => { return((x.createdAtLayerNum == y.createdAtLayerNum) ? 0 : (x.createdAtLayerNum < y.createdAtLayerNum) ? -1 : 1); }); List <ActionInfo> sortedByAvailableUptoLayerNum = new List <ActionInfo>(moverTypeChecker.procToActionInfo.Values.Where(x => x is AtomicActionInfo)); sortedByAvailableUptoLayerNum.Sort((x, y) => { return((x.availableUptoLayerNum == y.availableUptoLayerNum) ? 0 : (x.availableUptoLayerNum < y.availableUptoLayerNum) ? -1 : 1); }); Dictionary <int, HashSet <AtomicActionInfo> > pools = new Dictionary <int, HashSet <AtomicActionInfo> >(); int indexIntoSortedByCreatedLayerNum = 0; int indexIntoSortedByAvailableUptoLayerNum = 0; HashSet <AtomicActionInfo> currPool = new HashSet <AtomicActionInfo>(); while (indexIntoSortedByCreatedLayerNum < sortedByCreatedLayerNum.Count) { var currLayerNum = sortedByCreatedLayerNum[indexIntoSortedByCreatedLayerNum].createdAtLayerNum; pools[currLayerNum] = new HashSet <AtomicActionInfo>(currPool); while (indexIntoSortedByCreatedLayerNum < sortedByCreatedLayerNum.Count) { var actionInfo = sortedByCreatedLayerNum[indexIntoSortedByCreatedLayerNum] as AtomicActionInfo; if (actionInfo.createdAtLayerNum > currLayerNum) { break; } pools[currLayerNum].Add(actionInfo); indexIntoSortedByCreatedLayerNum++; } while (indexIntoSortedByAvailableUptoLayerNum < sortedByAvailableUptoLayerNum.Count) { var actionInfo = sortedByAvailableUptoLayerNum[indexIntoSortedByAvailableUptoLayerNum] as AtomicActionInfo; if (actionInfo.availableUptoLayerNum > currLayerNum) { break; } pools[currLayerNum].Remove(actionInfo); indexIntoSortedByAvailableUptoLayerNum++; } currPool = pools[currLayerNum]; } Program program = moverTypeChecker.program; MoverCheck moverChecking = new MoverCheck(linearTypeChecker, moverTypeChecker, decls); foreach (int layerNum in pools.Keys) { foreach (AtomicActionInfo first in pools[layerNum]) { Debug.Assert(first.moverType != MoverType.Top); if (first.moverType == MoverType.Atomic) { continue; } foreach (AtomicActionInfo second in pools[layerNum]) { if (first.IsRightMover) { moverChecking.CreateCommutativityChecker(program, first, second); moverChecking.CreateGatePreservationChecker(program, second, first); } if (first.IsLeftMover) { moverChecking.CreateCommutativityChecker(program, second, first); moverChecking.CreateGatePreservationChecker(program, first, second); moverChecking.CreateFailurePreservationChecker(program, second, first); } } } } foreach (ActionInfo actionInfo in moverTypeChecker.procToActionInfo.Values) { AtomicActionInfo atomicActionInfo = actionInfo as AtomicActionInfo; if (atomicActionInfo != null && atomicActionInfo.IsLeftMover && atomicActionInfo.hasAssumeCmd) { moverChecking.CreateNonBlockingChecker(program, atomicActionInfo); } } }
public static void AddCheckers(LinearTypeChecker linearTypeChecker, CivlTypeChecker civlTypeChecker, List<Declaration> decls) { if (civlTypeChecker.procToActionInfo.Count == 0) return; List<ActionInfo> sortedByCreatedLayerNum = new List<ActionInfo>(civlTypeChecker.procToActionInfo.Values.Where(x => x is AtomicActionInfo && !x.isExtern)); sortedByCreatedLayerNum.Sort((x, y) => { return (x.createdAtLayerNum == y.createdAtLayerNum) ? 0 : (x.createdAtLayerNum < y.createdAtLayerNum) ? -1 : 1; }); List<ActionInfo> sortedByAvailableUptoLayerNum = new List<ActionInfo>(civlTypeChecker.procToActionInfo.Values.Where(x => x is AtomicActionInfo && !x.isExtern)); sortedByAvailableUptoLayerNum.Sort((x, y) => { return (x.availableUptoLayerNum == y.availableUptoLayerNum) ? 0 : (x.availableUptoLayerNum < y.availableUptoLayerNum) ? -1 : 1; }); Dictionary<int, HashSet<AtomicActionInfo>> pools = new Dictionary<int, HashSet<AtomicActionInfo>>(); int indexIntoSortedByCreatedLayerNum = 0; int indexIntoSortedByAvailableUptoLayerNum = 0; HashSet<AtomicActionInfo> currPool = new HashSet<AtomicActionInfo>(); while (indexIntoSortedByCreatedLayerNum < sortedByCreatedLayerNum.Count) { var currLayerNum = sortedByCreatedLayerNum[indexIntoSortedByCreatedLayerNum].createdAtLayerNum; pools[currLayerNum] = new HashSet<AtomicActionInfo>(currPool); while (indexIntoSortedByCreatedLayerNum < sortedByCreatedLayerNum.Count) { var actionInfo = sortedByCreatedLayerNum[indexIntoSortedByCreatedLayerNum] as AtomicActionInfo; if (actionInfo.createdAtLayerNum > currLayerNum) break; pools[currLayerNum].Add(actionInfo); indexIntoSortedByCreatedLayerNum++; } while (indexIntoSortedByAvailableUptoLayerNum < sortedByAvailableUptoLayerNum.Count) { var actionInfo = sortedByAvailableUptoLayerNum[indexIntoSortedByAvailableUptoLayerNum] as AtomicActionInfo; if (actionInfo.availableUptoLayerNum > currLayerNum) break; pools[currLayerNum].Remove(actionInfo); indexIntoSortedByAvailableUptoLayerNum++; } currPool = pools[currLayerNum]; } // No atomic action has mover type Top Debug.Assert(pools.All(l => l.Value.All(a => a.moverType != MoverType.Top))); Program program = civlTypeChecker.program; MoverCheck moverChecking = new MoverCheck(linearTypeChecker, civlTypeChecker, decls); var moverChecks = from layer in pools.Keys from first in pools[layer] from second in pools[layer] where first.moverType != MoverType.Atomic select new { First = first, Second = second }; foreach (var moverCheck in moverChecks) { var first = moverCheck.First; var second = moverCheck.Second; if (first.IsRightMover) { moverChecking.CreateCommutativityChecker(program, first, second); moverChecking.CreateGatePreservationChecker(program, second, first); } if (first.IsLeftMover) { moverChecking.CreateCommutativityChecker(program, second, first); moverChecking.CreateGatePreservationChecker(program, first, second); moverChecking.CreateFailurePreservationChecker(program, second, first); } } foreach (AtomicActionInfo atomicActionInfo in sortedByCreatedLayerNum) { if (atomicActionInfo.IsLeftMover && atomicActionInfo.hasAssumeCmd) { moverChecking.CreateNonBlockingChecker(program, atomicActionInfo); } } }