public IDecompilationResult Transform() { ProcessDescriptor pd = _code as ProcessDescriptor; FSMTransformerTemplate templ = new FSMTransformerTemplate(_context, _code, _instance, _arguments); Function body = templ.GetAlgorithm(); _code.Implementation = body; foreach (var tup in templ.CoFSMs) { CoFSMInfo cfi = tup.Item2; cfi.Sensitivity.Add(cfi.CoStateSignal.Desc); FSMCombTemplate cotempl = new FSMCombTemplate(cfi); Function comb = cotempl.GetAlgorithm(); string name = _code.Name + "$comb"; ProcessDescriptor pdcomb = new ProcessDescriptor(name) { Kind = Process.EProcessKind.Triggered, Implementation = comb, GenuineImplementation = body, Sensitivity = cfi.Sensitivity.ToArray() }; _code.Owner.AddChild(pdcomb, name); } return(templ); }
private void AddCoStates(int issuePoint, LocalVariableState lvState, IEnumerable <TAVerb> states) { Contract.Requires(states != null); TAVerb first = states.First(); CoFSMInfo cfi = _coFSMs[first.Target]; if (cfi.AddVerbs(issuePoint, lvState, states)) { foreach (var tup in cfi.GetVerbs(issuePoint, lvState)) { TAVerb tav = tup.Item1; CoStateInfo csi = tup.Item2; if (csi.StateAction == null) { InitCoState(tav, csi); if (tav.During != null) { foreach (AbstractEvent ev in tav.During.Sensitivity) { cfi.Sensitivity.Add(((SignalBase)ev.Owner).Descriptor); } } } } } }
private void InitializeCoFSMs() { ProcessDescriptor pd = _code as ProcessDescriptor; if (pd != null) { TransactingComponent.TATarget[] coFSMs = pd.Instance.GetCoFSMs(); if (coFSMs != null) { foreach (TransactingComponent.TATarget target in coFSMs) { CoFSMInfo cfi = new CoFSMInfo(); _coFSMs[target.Target] = cfi; if (target.NeutralTA != null) { cfi.HasNeutralTA = true; AddCoStates(-1, LocalVariableState.Empty, target.NeutralTA); } else { cfi.HasNeutralTA = false; } } } } }
public void ImplementCoState(int issuePoint, IEnumerable <TAVerb> states, int step, IFunctionBuilder builder) { LocalVariableState lvState = _templ.ExportLocalVariableState(); AddCoStates(issuePoint, lvState, states); TAVerb first = states.First(); CoFSMInfo cfi = _coFSMs[first.Target]; var tup = cfi.GetVerbs(issuePoint, lvState).ElementAt(step); CoStateInfo csi = tup.Item2; ImplementCoStateAction(cfi, csi, builder); }
private void ImplementCoStateAction(CoFSMInfo cfi, CoStateInfo csi, IFunctionBuilder builder) { builder.InlineCall(csi.StateAction, new Expression[0], new Variable[0], true); builder.Store(cfi.NextCoState, csi.StateExpr); /* * CoStateInfo next = csi.Next; * if (next == null && cfi.HasNeutralTA) * next = cfi.FirstNeutral; * if (next != null) * { * builder.Store(cfi.NextCoState, next.StateExpr); * } * */ }
private void CreateCoStateValues() { foreach (var kvp in _coFSMs) { ITransactionSite target = kvp.Key; CoFSMInfo cfi = kvp.Value; string ename, fname; if (target.Name == null) { ename = "E_" + target.Host.Descriptor.Name + "_CoState"; fname = "m_" + target.Host.Descriptor.Name + "_CoState"; } else { ename = "E_" + target.Host.Descriptor.Name + "_" + target.Name + "_CoState"; fname = "m_" + target.Host.Descriptor.Name + "_" + target.Name + "_CoState"; } Type tState = CreateEnum(ename, cfi.TotalStates); TypeDescriptor tdState = (TypeDescriptor)tState; ComponentDescriptor owner = (ComponentDescriptor)_code.Owner; owner.AddChild(tdState, tdState.Name); Type tStateSignal = typeof(Signal <>).MakeGenericType(tState); FieldBuilder fbStateSignal = _tComponent.DefineField(fname, tStateSignal, FieldAttributes.Private); Array enumValues = tState.GetEnumValues(); object initVal; if (cfi.HasNeutralTA) { initVal = cfi.FirstNeutral.StateValue; } else { initVal = enumValues.GetValue(0); } var sdState = owner.CreateSignalInstance(fname, initVal); cfi.CoStateSignal = new SignalRef(sdState, SignalRef.EReferencedProperty.Instance); cfi.CoStateType = tStateSignal; cfi.NextCoState.PlaceHolder = new SignalRef(sdState, SignalRef.EReferencedProperty.Next); foreach (CoStateInfo csi in cfi.StateInfos) { csi.StateValue = enumValues.GetValue(csi.StateIndex); csi.StateExpr.PlaceHolder = LiteralReference.CreateConstant(csi.StateValue); } } }
public FSMCombTemplate(CoFSMInfo cfi) { Contract.Requires(cfi != null); _cfi = cfi; }
protected override void DeclareAlgorithm() { Dissect(); Initialize(); InitializeCoFSMs(); DecompileStates(); CreateStateValues(); CreateCoStateValues(); SignalRef curState = new SignalRef(_stateSignal.Desc, SignalRef.EReferencedProperty.Cur); ProcessDescriptor pd = (ProcessDescriptor)_code; Func <bool> predFunc = pd.Instance.Predicate; LiteralReference predInstRef = LiteralReference.CreateConstant(predFunc.Target); StackElement arg = new StackElement(predInstRef, predFunc.Target, EVariability.ExternVariable); Expression cond = _templ.GetCallExpression(predFunc.Method, arg).Expr; Expression[] e0 = new Expression[0]; Variable[] v0 = new Variable[0]; If(cond); { foreach (var kvp in _coFSMs) { CoFSMInfo cfi = kvp.Value; SignalRef srCor = new SignalRef(cfi.CoStateSignal.Desc, SignalRef.EReferencedProperty.Cur); Expression lrCo = new LiteralReference(srCor); CaseStatement csc = Switch(lrCo); { for (int i = 0; i < cfi.TotalStates; i++) { CoStateInfo csi = cfi.StateInfos[i]; Expression stateValue = LiteralReference.CreateConstant(csi.StateValue); CoStateInfo csin = csi.Next; if (csin == null && cfi.HasNeutralTA) { csin = cfi.FirstNeutral; } Case(stateValue); { if (csin != null) { ImplementCoStateAction(cfi, csin, this); } Break(csc); } EndCase(); } } EndSwitch(); } CaseStatement cs = Switch(curState); { IEnumerable <StateInfo> states = _stateLookup.Values.OrderBy(si => si.StateIndex); foreach (StateInfo state in states) { Case(state.StateExpr.PlaceHolder); { InlineCall(state.StateFun, e0, v0, true); Break(cs); } EndCase(); } } EndSwitch(); } EndIf(); }