private void ImplementFlow(Flow flow, IAlgorithmBuilder pbuilder, SLVSignal cwSignal, HashSet <ISignalOrPortDescriptor> sensitivity)
{
if (FlowMatrix.IsDontCareFlow(flow))
{
int valOffset = _vfc.GetValueWordOffset(flow.Target);
int valWidth = _vfc.GetValueWordWidth(flow.Target);
LiteralReference lrCWValSlice;
if (flow.Target.Desc.ElementType.CILType.Equals(typeof(StdLogic)))
{
lrCWValSlice = new LiteralReference(
((ISignal)cwSignal[valOffset])
.ToSignalRef(SignalRef.EReferencedProperty.Cur));
}
else
{
lrCWValSlice = new LiteralReference(
((ISignal)cwSignal[valOffset + valWidth - 1, valOffset])
.ToSignalRef(SignalRef.EReferencedProperty.Cur));
}
pbuilder.Store(flow.Target, lrCWValSlice);
}
else if (flow is SignalFlow)
{
var sflow = flow as SignalFlow;
pbuilder.Store(flow.Target, sflow.Source);
sensitivity.Add(sflow.Source.Desc);
}
else
{
var vflow = flow as ValueFlow;
pbuilder.Store(vflow.Target,
LiteralReference.CreateConstant(vflow.Value));
}
}
public override void AssembleStagedDecoderComb(ValueFlowCoder vfc, LiteralReference lrCWSelSlice,
IAlgorithmBuilder pbuilder, SLVSignal cwSignal, HashSet <ISignalOrPortDescriptor> sensitivity,
bool registered)
{
_encFlow0.AssembleStagedDecoderComb(vfc, lrCWSelSlice, pbuilder, cwSignal, sensitivity, registered);
_encFlow1.AssembleStagedDecoderComb(vfc, lrCWSelSlice, pbuilder, cwSignal, sensitivity, registered);
}
public void Implement(IAlgorithmBuilder builder)
{
foreach (IProcess p in ProcessDefs)
{
p.Implement(builder);
}
}
public override void AssembleStagedDecoderSync(int[] syms, int selWidth, LiteralReference lrCWSelSlice,
IAutoBinder binder, IAlgorithmBuilder pbuilder, bool registered)
{
int[] syms0 = syms.Select(i => _encMap0[i - 1]).ToArray();
int[] syms1 = syms.Select(i => _encMap1[i - 1]).ToArray();
_encFlow0.AssembleStagedDecoderSync(syms0, selWidth, lrCWSelSlice, binder, pbuilder, registered);
_encFlow1.AssembleStagedDecoderSync(syms1, selWidth, lrCWSelSlice, binder, pbuilder, registered);
}
public void Implement(IAlgorithmBuilder builder)
{
IDescriptive idesc = (IDescriptive)DrivenSignal;
ISignalOrPortDescriptor desc = (ISignalOrPortDescriptor)idesc.Descriptor;
builder.Store(DrivenSignal.ToSignalRef(SignalRef.EReferencedProperty.Next),
Source.GetExpression());
}
public void Implement(IAlgorithmBuilder builder)
{
if (ProcessDef == null)
{
throw new InvalidOperationException("No valid process definition");
}
ProcessDef.Implement(builder);
}
internal void AssembleStagedDecoderComb(IAlgorithmBuilder pbuilder, SLVSignal cwSignal,
HashSet <ISignalOrPortDescriptor> sensitivity, bool registered)
{
LiteralReference lrCWSelSlice = null;
if (SelWidth != 0)
{
lrCWSelSlice = new LiteralReference(
((ISignal)cwSignal[SelOffset + SelWidth - 1, SelOffset])
.ToSignalRef(SignalRef.EReferencedProperty.Cur));
}
_encFlow.AssembleStagedDecoderComb(_vfc, lrCWSelSlice, pbuilder, cwSignal, sensitivity, registered);
}
internal void AssembleStagedDecoderSync(IAutoBinder binder, IAlgorithmBuilder pbuilder, SLVSignal cwSignal, bool registered)
{
LiteralReference lrCWSelSlice = null;
if (SelWidth != 0)
{
lrCWSelSlice = new LiteralReference(
((ISignal)cwSignal[SelOffset + SelWidth - 1, SelOffset])
.ToSignalRef(SignalRef.EReferencedProperty.Cur));
}
_encFlow.AssembleStagedDecoderSync(Enumerable.Range(1, _encFlow.NumSymbols).ToArray(),
SelWidth, lrCWSelSlice, binder, pbuilder, registered);
}
internal void AssembleDecoder(IAlgorithmBuilder pbuilder, SLVSignal cwSignal, HashSet <ISignalOrPortDescriptor> sensitivity)
{
if (_encFlow.NumSymbols == 0)
{
foreach (var target in _targets)
{
pbuilder.Store(target, LiteralReference.CreateConstant(target.Desc.InitialValue));
}
}
else if (_encFlow.NumSymbols == 1)
{
var pflow = _encFlow.BwdEnc[0];
foreach (var flow in pflow.Flows)
{
ImplementFlow(flow, pbuilder, cwSignal, sensitivity);
}
}
else
{
var lrCWSelSlice = new LiteralReference(
((ISignal)cwSignal[SelOffset + SelWidth - 1, SelOffset])
.ToSignalRef(SignalRef.EReferencedProperty.Cur));
pbuilder.Switch(lrCWSelSlice);
for (int i = 0; i < _encFlow.NumSymbols; i++)
{
var selValue = StdLogicVector.FromUInt((uint)i, SelWidth);
var pflow = _encFlow.BwdEnc[i];
if (i + 1 == _encFlow.NumSymbols)
{
pbuilder.DefaultCase();
}
else
{
pbuilder.Case(LiteralReference.CreateConstant(selValue));
}
foreach (var flow in pflow.Flows)
{
ImplementFlow(flow, pbuilder, cwSignal, sensitivity);
}
pbuilder.EndCase();
}
pbuilder.EndSwitch();
}
}
public override void AssembleStagedDecoderComb(ValueFlowCoder vfc, LiteralReference lrCWSelSlice,
IAlgorithmBuilder pbuilder, SLVSignal cwSignal, HashSet<ISignalOrPortDescriptor> sensitivity,
bool registered)
{
_encFlow0.AssembleStagedDecoderComb(vfc, lrCWSelSlice, pbuilder, cwSignal, sensitivity, registered);
_encFlow1.AssembleStagedDecoderComb(vfc, lrCWSelSlice, pbuilder, cwSignal, sensitivity, registered);
}
/// <summary>
/// Emits a call to output a textual diagnostic message.
/// </summary>
/// <param name="builder">algorithm builder</param>
/// <param name="args">output arguments</param>
public static void ReportLine(this IAlgorithmBuilder builder, params object[] args)
{
var arg = Expression.Concat(args.Select(_ => ToExpression(_)).ToArray());
builder.Call(IntrinsicFunctions.ReportLine(arg), arg);
}
public void Construct(IAlgorithmBuilder algorithmBuilder)
{
algorithmBuilder.BuildStrategyPatternParameters();
algorithmBuilder.BuildStrategyPattern();
}
private void ImplementFlow(ValueFlowCoder vfc, Flow flow, IAlgorithmBuilder pbuilder, SLVSignal cwSignal, HashSet<ISignalOrPortDescriptor> sensitivity)
{
if (FlowMatrix.IsDontCareFlow(flow))
{
int valOffset = vfc.GetValueWordOffset(flow.Target);
int valWidth = vfc.GetValueWordWidth(flow.Target);
LiteralReference lrCWValSlice;
if (flow.Target.Desc.ElementType.CILType.Equals(typeof(StdLogic)))
{
lrCWValSlice = new LiteralReference(
((ISignal)cwSignal[valOffset])
.ToSignalRef(SignalRef.EReferencedProperty.Cur));
}
else
{
lrCWValSlice = new LiteralReference(
((ISignal)cwSignal[valOffset + valWidth - 1, valOffset])
.ToSignalRef(SignalRef.EReferencedProperty.Cur));
}
pbuilder.Store(flow.Target, lrCWValSlice);
}
else if (flow is SignalFlow)
{
var sflow = flow as SignalFlow;
pbuilder.Store(flow.Target, sflow.Source);
sensitivity.Add(sflow.Source.Desc);
}
else
{
var vflow = flow as ValueFlow;
pbuilder.Store(vflow.Target,
LiteralReference.CreateConstant(vflow.Value));
}
}
internal void AssembleStagedDecoderComb(IAlgorithmBuilder pbuilder, SLVSignal cwSignal,
HashSet<ISignalOrPortDescriptor> sensitivity, bool registered)
{
LiteralReference lrCWSelSlice = null;
if (SelWidth != 0)
{
lrCWSelSlice = new LiteralReference(
((ISignal)cwSignal[SelOffset + SelWidth - 1, SelOffset])
.ToSignalRef(SignalRef.EReferencedProperty.Cur));
}
_encFlow.AssembleStagedDecoderComb(_vfc, lrCWSelSlice, pbuilder, cwSignal, sensitivity, registered);
}
internal void AssembleStagedDecoderSync(IAutoBinder binder, IAlgorithmBuilder pbuilder, SLVSignal cwSignal, bool registered)
{
LiteralReference lrCWSelSlice = null;
if (SelWidth != 0)
{
lrCWSelSlice = new LiteralReference(
((ISignal)cwSignal[SelOffset + SelWidth - 1, SelOffset])
.ToSignalRef(SignalRef.EReferencedProperty.Cur));
}
_encFlow.AssembleStagedDecoderSync(Enumerable.Range(1, _encFlow.NumSymbols).ToArray(),
SelWidth, lrCWSelSlice, binder, pbuilder, registered);
}
public virtual void AssembleStagedDecoderComb(
ValueFlowCoder vfc,
LiteralReference lrCWSelSlice,
IAlgorithmBuilder pbuilder, SLVSignal cwSignal,
HashSet <ISignalOrPortDescriptor> sensitivity,
bool registered)
{
if (NumSymbols == 0)
{
foreach (var target in Targets)
{
pbuilder.Store(target, LiteralReference.CreateConstant(target.Desc.InitialValue));
}
}
else if (NumSymbols == 1)
{
var pflow = BwdEnc[0];
foreach (var flow in pflow.Flows)
{
ImplementFlow(vfc, flow, pbuilder, cwSignal, sensitivity);
}
}
else
{
var symbol = registered ? _symbold : _symbol;
pbuilder.Switch(symbol.SignalInstance.ToSignalRef(SignalRef.EReferencedProperty.Cur));
for (int i = 0; i < NumSymbols; i++)
{
var selValue = _selSymbols.GetValue(i);
var pflow = BwdEnc[i];
pbuilder.Case(LiteralReference.CreateConstant(selValue));
foreach (var flow in pflow.Flows)
{
ImplementFlow(vfc, flow, pbuilder, cwSignal, sensitivity);
}
pbuilder.EndCase();
}
var nulls = StdLogicVector._0s(NumSymbols);
pbuilder.Case(LiteralReference.CreateConstant(nulls));
{
foreach (var target in Targets)
{
int width = Marshal.SerializeForHW(target.Desc.InitialValue).Size;
pbuilder.Store(target,
LiteralReference.CreateConstant(StdLogicVector._0s(width)));
}
}
pbuilder.EndCase();
pbuilder.DefaultCase();
{
foreach (var target in Targets)
{
int width = Marshal.SerializeForHW(target.Desc.InitialValue).Size;
pbuilder.Store(target,
LiteralReference.CreateConstant(StdLogicVector.Xs(width)));
}
}
pbuilder.EndCase();
pbuilder.EndSwitch();
}
}
public void Implement(IAlgorithmBuilder builder)
{
builder.Store(_dest, _expr);
}
public void Implement(IAlgorithmBuilder builder)
{
}
public virtual void AssembleStagedDecoderComb(
ValueFlowCoder vfc,
LiteralReference lrCWSelSlice,
IAlgorithmBuilder pbuilder, SLVSignal cwSignal,
HashSet<ISignalOrPortDescriptor> sensitivity,
bool registered)
{
if (NumSymbols == 0)
{
foreach (var target in Targets)
{
pbuilder.Store(target, LiteralReference.CreateConstant(target.Desc.InitialValue));
}
}
else if (NumSymbols == 1)
{
var pflow = BwdEnc[0];
foreach (var flow in pflow.Flows)
{
ImplementFlow(vfc, flow, pbuilder, cwSignal, sensitivity);
}
}
else
{
var symbol = registered ? _symbold : _symbol;
pbuilder.Switch(symbol.SignalInstance.ToSignalRef(SignalRef.EReferencedProperty.Cur));
for (int i = 0; i < NumSymbols; i++)
{
var selValue = _selSymbols.GetValue(i);
var pflow = BwdEnc[i];
pbuilder.Case(LiteralReference.CreateConstant(selValue));
foreach (var flow in pflow.Flows)
{
ImplementFlow(vfc, flow, pbuilder, cwSignal, sensitivity);
}
pbuilder.EndCase();
}
var nulls = StdLogicVector._0s(NumSymbols);
pbuilder.Case(LiteralReference.CreateConstant(nulls));
{
foreach (var target in Targets)
{
int width = Marshal.SerializeForHW(target.Desc.InitialValue).Size;
pbuilder.Store(target,
LiteralReference.CreateConstant(StdLogicVector._0s(width)));
}
}
pbuilder.EndCase();
pbuilder.DefaultCase();
{
foreach (var target in Targets)
{
int width = Marshal.SerializeForHW(target.Desc.InitialValue).Size;
pbuilder.Store(target,
LiteralReference.CreateConstant(StdLogicVector.Xs(width)));
}
}
pbuilder.EndCase();
pbuilder.EndSwitch();
}
}
public virtual void AssembleStagedDecoderSync(int[] syms, int selWidth,
LiteralReference lrCWSelSlice, IAutoBinder binder, IAlgorithmBuilder pbuilder,
bool registered)
{
if (NumSymbols < 2)
return;
CreateSelSymbol(binder, registered);
pbuilder.Switch(lrCWSelSlice);
for (int i = 0; i < syms.Length; i++)
{
var selValue = StdLogicVector.FromUInt((uint)i, selWidth);
pbuilder.Case(LiteralReference.CreateConstant(selValue));
int sym = syms[i];
var symbol = _selSymbols.GetValue(sym - 1);
pbuilder.Store(
_symbol.SignalInstance.ToSignalRef(SignalRef.EReferencedProperty.Next),
LiteralReference.CreateConstant(symbol));
pbuilder.EndCase();
}
pbuilder.DefaultCase();
{
pbuilder.Store(
_symbol.SignalInstance.ToSignalRef(SignalRef.EReferencedProperty.Next),
LiteralReference.CreateConstant(StdLogicVector.Xs(NumSymbols)));
}
pbuilder.EndCase();
if (registered)
{
pbuilder.Store(
_symbold.SignalInstance.ToSignalRef(SignalRef.EReferencedProperty.Next),
_symbol.SignalInstance.ToSignalRef(SignalRef.EReferencedProperty.Cur));
}
pbuilder.EndSwitch();
}
public override void AssembleStagedDecoderSync(int[] syms, int selWidth, LiteralReference lrCWSelSlice,
IAutoBinder binder, IAlgorithmBuilder pbuilder, bool registered)
{
int[] syms0 = syms.Select(i => _encMap0[i - 1]).ToArray();
int[] syms1 = syms.Select(i => _encMap1[i - 1]).ToArray();
_encFlow0.AssembleStagedDecoderSync(syms0, selWidth, lrCWSelSlice, binder, pbuilder, registered);
_encFlow1.AssembleStagedDecoderSync(syms1, selWidth, lrCWSelSlice, binder, pbuilder, registered);
}
internal void AssembleDecoder(IAlgorithmBuilder pbuilder, SLVSignal cwSignal, HashSet<ISignalOrPortDescriptor> sensitivity)
{
if (_encFlow.NumSymbols == 0)
{
foreach (var target in _targets)
{
pbuilder.Store(target, LiteralReference.CreateConstant(target.Desc.InitialValue));
}
}
else if (_encFlow.NumSymbols == 1)
{
var pflow = _encFlow.BwdEnc[0];
foreach (var flow in pflow.Flows)
{
ImplementFlow(flow, pbuilder, cwSignal, sensitivity);
}
}
else
{
var lrCWSelSlice = new LiteralReference(
((ISignal)cwSignal[SelOffset + SelWidth - 1, SelOffset])
.ToSignalRef(SignalRef.EReferencedProperty.Cur));
pbuilder.Switch(lrCWSelSlice);
for (int i = 0; i < _encFlow.NumSymbols; i++)
{
var selValue = StdLogicVector.FromUInt((uint)i, SelWidth);
var pflow = _encFlow.BwdEnc[i];
if (i + 1 == _encFlow.NumSymbols)
pbuilder.DefaultCase();
else
pbuilder.Case(LiteralReference.CreateConstant(selValue));
foreach (var flow in pflow.Flows)
{
ImplementFlow(flow, pbuilder, cwSignal, sensitivity);
}
pbuilder.EndCase();
}
pbuilder.EndSwitch();
}
}
private void ImplementJoin(JoinParams jp, IAlgorithmBuilder builder, StateInfo sin)
{
Contract.Requires<ArgumentNullException>(jp != null);
Contract.Requires<ArgumentNullException>(builder != null);
Contract.Requires<ArgumentNullException>(sin != null);
var jspec = new FunctionSpec(typeof(bool))
{
IntrinsicRep = IntrinsicFunctions.Join(jp)
};
var jcall = new FunctionCall()
{
Callee = jspec,
Arguments = new Expression[0],
ResultType = typeof(bool)
};
builder.If(jcall);
var pi1 = new ProceedWithStateInfo()
{
TargetState = sin,
TargetWaitState = false,
LambdaTransition = true
};
var pspec1 = new FunctionSpec(typeof(void))
{
IntrinsicRep = IntrinsicFunctions.ProceedWithState(pi1)
};
builder.Call(pspec1, LiteralReference.CreateConstant(pi1));
builder.Else();
var sin2 = sin.Fork(sin.ILState);
var pi2 = new ProceedWithStateInfo()
{
TargetState = sin,
TargetWaitState = true,
LambdaTransition = false
};
var pspec2 = new FunctionSpec(typeof(void))
{
IntrinsicRep = IntrinsicFunctions.ProceedWithState(pi2)
};
builder.Call(pspec2, LiteralReference.CreateConstant(pi2));
builder.EndIf();
if (_curCoFSM != null)
_curCoFSM.Dependencies.Add(jp.JoinedTask);
}
public virtual void AssembleStagedDecoderSync(int[] syms, int selWidth,
LiteralReference lrCWSelSlice, IAutoBinder binder, IAlgorithmBuilder pbuilder,
bool registered)
{
if (NumSymbols < 2)
{
return;
}
CreateSelSymbol(binder, registered);
pbuilder.Switch(lrCWSelSlice);
for (int i = 0; i < syms.Length; i++)
{
var selValue = StdLogicVector.FromUInt((uint)i, selWidth);
pbuilder.Case(LiteralReference.CreateConstant(selValue));
int sym = syms[i];
var symbol = _selSymbols.GetValue(sym - 1);
pbuilder.Store(
_symbol.SignalInstance.ToSignalRef(SignalRef.EReferencedProperty.Next),
LiteralReference.CreateConstant(symbol));
pbuilder.EndCase();
}
pbuilder.DefaultCase();
{
pbuilder.Store(
_symbol.SignalInstance.ToSignalRef(SignalRef.EReferencedProperty.Next),
LiteralReference.CreateConstant(StdLogicVector.Xs(NumSymbols)));
}
pbuilder.EndCase();
if (registered)
{
pbuilder.Store(
_symbold.SignalInstance.ToSignalRef(SignalRef.EReferencedProperty.Next),
_symbol.SignalInstance.ToSignalRef(SignalRef.EReferencedProperty.Cur));
}
pbuilder.EndSwitch();
}
