/// <summary>
/// Returns <c>true</c> if <paramref name="target"/> is the destination of any contained dataflows.
/// </summary>
public bool ContainsTarget(SignalRef target)
{
return(_flows.ContainsKey(target));
}
/// <summary>
/// Constructs a new instance.
/// </summary>
/// <param name="target">target of dataflow</param>
public Flow(SignalRef target)
{
Target = target;
}
/// <summary>
/// Returns all dataflows targeting specified signal, regardless of their activation times.
/// </summary>
/// <param name="target">signal target to query for</param>
/// <returns>all dataflows targeting specified signal</returns>
public IEnumerable <Flow> GetFlowsTo(SignalRef target)
{
return(_graphs.SelectMany(g => g.GetFlowsTo(target))
.Union(_neutral.GetFlowsTo(target))
.Distinct());
}
private IEnumerable <ITimedFlow> ConstructNetwork(SignalRef target, IEnumerable <ITimedFlow> flows)
{
var groupedByDelay = flows
.GroupBy(tf => tf is TimedSignalFlow ? ((TimedSignalFlow)tf).Delay : 0)
.OrderBy(grp => grp.Key);
var curTarget = target;
int remainingFanIn = flows.Count();
long generation = 0;
var pumpOut = new List <SignalFlow>();
foreach (var delayGroup in groupedByDelay)
{
foreach (var tflow in delayGroup)
{
var tsf = tflow as TimedSignalFlow;
var tvf = tflow as TimedValueFlow;
if (tsf != null)
{
long flowDelay = tsf.Delay - generation;
if (flowDelay == 0)
{
yield return(new TimedSignalFlow(tsf.Source, curTarget, tsf.Time, 0));
}
else
{
SignalBase tmpSig = Signals.CreateInstance(tsf.Source.Desc.InitialValue);
tmpSig.Descriptor.TagTemporary(_tmpIdx++);
yield return(new TimedSignalFlow(
tsf.Source,
tmpSig.ToSignalRef(SignalRef.EReferencedProperty.Next),
tsf.Time, 0));
yield return(new TimedSignalFlow(
tmpSig.ToSignalRef(SignalRef.EReferencedProperty.Cur),
curTarget,
tsf.Time + flowDelay, 0));
}
long start = tsf.Time + tsf.Delay;
foreach (var pump in pumpOut)
{
yield return(new TimedSignalFlow(pump.Source, pump.Target, start, 0));
start--;
}
}
else
{
// remark: as of now, delay is always 0
yield return(new TimedValueFlow(tvf.Value, curTarget, tvf.Time));
}
}
long delay = delayGroup.Key;
remainingFanIn -= delayGroup.Count();
#if false
if (remainingFanIn > 1)
{
var stageInSignal = _binder.GetSignal(EPortUsage.Default,
"icn_" + target.Desc.Name + "_" + generation + "_in",
null,
target.Desc.InitialValue);
var stageOutSignal = _binder.GetSignal(EPortUsage.Default,
"icn_" + target.Desc.Name + "_" + generation + "_out",
null,
target.Desc.InitialValue);
_stageInSignals.Add(stageInSignal);
_stageOutSignals.Add(stageOutSignal);
var pumpSource = new SignalRef(stageOutSignal.ToSignalRef(SignalRef.EReferencedProperty.Cur));
pumpOut.Add(new SignalFlow(pumpSource, curTarget));
curTarget = new SignalRef(stageInSignal.ToSignalRef(SignalRef.EReferencedProperty.Next));
++generation;
}
#endif
}
}
public object EvalSignalRef(SignalRef signalRef)
{
return(DoEvalSignalRef(signalRef));
}
/// <summary>
/// Creates a dataflow which transfers the "don't care" literal to a signal target of choice
/// </summary>
/// <param name="target">signal target</param>
/// <returns>the resulting dataflow</returns>
public static ValueFlow CreateDontCareFlow(SignalRef target)
{
return(new ValueFlow(StdLogicVector.DCs(
Marshal.SerializeForHW(target.Desc.InitialValue).Size), target));
}
/// <summary>
/// Constructs a new instance.
/// </summary>
/// <param name="source">source of dataflow</param>
/// <param name="target">target of dataflow</param>
public SignalFlow(SignalRef source, SignalRef target) :
base(target)
{
Source = source;
}
public override bool Rewrite(CodeDescriptor decompilee, Expression waitObject, IDecompiler stack, IFunctionBuilder builder)
{
if (stack.HasAttribute <Analysis.M2M.HLS>())
{
return(true);
}
var curps = DesignContext.Instance.CurrentProcess;
SLSignal clk = (SLSignal)curps.Sensitivity[0].Owner;
SignalRef srEdge;
if (curps.Predicate.Equals((Func <bool>)clk.RisingEdge))
{
srEdge = SignalRef.Create(clk.Descriptor, SignalRef.EReferencedProperty.RisingEdge);
}
else
{
srEdge = SignalRef.Create(clk.Descriptor, SignalRef.EReferencedProperty.FallingEdge);
}
var lrEdge = new LiteralReference(srEdge);
int nwait = 0;
var nwaitEx = waitObject.Children[0];
bool nwaitConst = nwaitEx.IsConst();
if (nwaitConst)
{
nwait = (int)TypeConversions.ConvertValue(
nwaitEx.Eval(DefaultEvaluator.DefaultConstEvaluator),
typeof(int));
}
var fspec = new FunctionSpec(typeof(void))
{
IntrinsicRep = IntrinsicFunctions.Wait(WaitParams.EWaitKind.WaitUntil)
};
Variable v = null;
LiteralReference lrV = null;
if (!nwaitConst || nwait > 3)
{
v = new Variable(typeof(int))
{
Name = "_wait_i" + (ictr++)
};
builder.DeclareLocal(v);
lrV = new LiteralReference(v);
builder.Store(v, LiteralReference.CreateConstant((int)0));
var loop = builder.Loop();
builder.If(Expression.Equal(lrV, nwaitEx));
{
builder.Break(loop);
}
builder.EndIf();
}
int ncalls = 1;
if (nwaitConst && nwait <= 3)
{
ncalls = nwait;
}
for (int i = 0; i < ncalls; i++)
{
builder.Call(fspec, lrEdge);
}
if (!nwaitConst || nwait > 3)
{
builder.Store(v, lrV + LiteralReference.CreateConstant((int)1));
builder.EndLoop();
}
return(true);
}
private int ComputeFuMuxCost(SignalRef target)
{
return(ComputeFuMuxCost(_fuMuxIn[target]));
}
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();
}
public int GetValueWordWidth(SignalRef target)
{
return(_widthMap[target]);
}
public int GetValueWordOffset(SignalRef target)
{
return(_offsetMap[target]);
}
/// <summary>
/// Visits a signal reference literal. The default implementation saves it to <c>_tlit</c>.
/// </summary>
/// <param name="signalRef">signal reference literal</param>
public virtual void VisitSignalRef(SignalRef signalRef)
{
_tlit = signalRef;
}
public void VisitSignalRef(SignalRef signalRef)
{
_result = signalRef;
}
/// <summary>
/// Constructs a new instance.
/// </summary>
/// <param name="source">source of dataflow</param>
/// <param name="target">target of dataflow</param>
/// <param name="delay">transport delay</param>
public DelayedSignalFlow(SignalRef source, SignalRef target, long delay) :
base(source, target)
{
Delay = delay;
}
public ConcurrentStatement(SignalRef targetSignal, Expression sourceExpression)
{
TargetSignal = targetSignal;
SourceExpression = sourceExpression;
}
/// <summary>
/// Constructs a new instance.
/// </summary>
/// <param name="source">source of dataflow</param>
/// <param name="target">target of dataflow</param>
/// <param name="time">timestamp when dataflow is active</param>
public TimestampedSignalFlow(SignalRef source, SignalRef target, long time) :
base(source, target)
{
Time = time;
}
private IEnumerable <SignalArgumentDescriptor> InspectMethod(MethodDescriptor md)
{
List <Statement> stmts = md.Implementation.Body.GetAtomicStatements();
IEnumerable <StoreStatement> stores = stmts.Select(s => s as StoreStatement).Where(s => s != null);
Dictionary <ISignalOrPortDescriptor, SignalArgumentDescriptor> map =
new Dictionary <ISignalOrPortDescriptor, SignalArgumentDescriptor>();
int order = md.GetArguments().Count();
foreach (StoreStatement stmt in stores)
{
SignalRef sref = stmt.Container as SignalRef;
if (sref == null)
{
continue;
}
if (sref.Desc is SignalArgumentDescriptor)
{
continue;
}
SignalArgumentDescriptor sad;
if (!map.TryGetValue(sref.Desc, out sad))
{
string name = "a_" + sref.Desc.Name;
SignalDescriptor sd = sref.Desc as SignalDescriptor;
PortDescriptor pd = sref.Desc as PortDescriptor;
SignalBase signalInst;
if (pd != null)
{
signalInst = ((SignalDescriptor)pd.BoundSignal).Instance;
}
else
{
signalInst = sd.Instance;
}
ArgumentDescriptor.EArgDirection flowDir;
if (pd == null)
{
flowDir = ArgumentDescriptor.EArgDirection.InOut;
}
else
{
switch (pd.Direction)
{
case EFlowDirection.In:
flowDir = ArgumentDescriptor.EArgDirection.In;
break;
case EFlowDirection.InOut:
flowDir = ArgumentDescriptor.EArgDirection.InOut;
break;
case EFlowDirection.Out:
flowDir = ArgumentDescriptor.EArgDirection.Out;
break;
default:
throw new NotImplementedException();
}
}
sad = new SignalArgumentDescriptor(
SignalRef.Create(sref.Desc, SignalRef.EReferencedProperty.Instance),
ArgumentDescriptor.EArgDirection.In,
flowDir,
EVariability.Constant,
order++);
map[sref.Desc] = sad;
}
SignalRef srefArg = new SignalRef(sad, sref.Prop, sref.Indices, sref.IndexSample, sref.IsStaticIndex);
stmt.Container = srefArg;
}
foreach (SignalArgumentDescriptor sad in map.Values)
{
md.AddChild(sad, sad.Argument.Name);
}
return(map.Values.OrderBy(k => k.Order));
}
/// <summary>
/// Constructs a new instance.
/// </summary>
/// <param name="source">source of dataflow</param>
/// <param name="target">target of dataflow</param>
/// <param name="time">timestamp when dataflow is active</param>
/// <param name="delay">transport delay</param>
public TimedSignalFlow(SignalRef source, SignalRef target, long time, long delay) :
base(source, target)
{
Time = time;
Delay = delay;
}
public object DefaultEvalSignalRef(SignalRef signalRef)
{
return(SignalRef.DefaultEval(signalRef, this));
}
/// <summary>
/// Constructs a new instance.
/// </summary>
/// <param name="value">constant value to transfer</param>
/// <param name="target">target signal</param>
public ValueFlow(object value, SignalRef target) :
base(target)
{
Value = value;
}
/// <summary>
/// Removes the dataflow targeting specified signal at specified c-step
/// </summary>
/// <param name="cstep">the c-step</param>
/// <param name="target">target to which dataflow is to be removed</param>
public void Remove(int cstep, SignalRef target)
{
_graphs[cstep].Remove(target);
}
/// <summary>
/// Constructs a new instance.
/// </summary>
/// <param name="value">constant value to transfer</param>
/// <param name="target">target of dataflow</param>
/// <param name="time">timestamp when dataflow is active</param>
public TimedValueFlow(object value, SignalRef target, long time) :
base(value, target)
{
Time = time;
}
public void Remove(SignalRef target)
{
_flows.Remove(target);
Debug.Assert(_flows.Values.All(f => f is ValueFlow || !((SignalFlow)f).Source.Equals(target)));
}
public void AddAccessor(InlineFieldMapperTransactionSite taSite, bool needRead, bool needWrite)
{
var srWrEn = needWrite ? SignalRef.Create(taSite._wrEn, SignalRef.EReferencedProperty.Cur) : null;
var lrWrEn = needWrite ? new LiteralReference(srWrEn) : null;
var srDataIn = needWrite ? SignalRef.Create(taSite._dataIn, SignalRef.EReferencedProperty.Cur) : null;
var lrDataIn = needWrite ? new LiteralReference(srDataIn) : null;
var srDataOut = needRead ? SignalRef.Create(taSite._dataOut, SignalRef.EReferencedProperty.Next) : null;
var hi = LiteralReference.CreateConstant(StdLogic._1);
var elemType = taSite._literal.Type;
var lrVar = new LiteralReference((Literal)taSite._literal);
var convDataIn = needWrite ? IntrinsicFunctions.Cast(lrDataIn, typeof(StdLogicVector), elemType) : null;
var convVar = needRead ? IntrinsicFunctions.Cast(lrVar, elemType.CILType, taSite._dataOut.ElementType) : null;
bool isBool = taSite._literal.Type.CILType.Equals(typeof(bool));
var lr1 = LiteralReference.CreateConstant((StdLogicVector)"1");
var lr0 = LiteralReference.CreateConstant((StdLogicVector)"0");
if (needWrite)
{
BodyBuilder.If(Expression.Equal(lrWrEn, hi));
{
if (isBool)
{
BodyBuilder.Store(taSite._literal, Expression.Equal(lrDataIn, lr1));
}
else
{
BodyBuilder.Store(taSite._literal, convDataIn);
}
var diagOut = taSite.Host as ISupportsDiagnosticOutput;
if (diagOut != null && diagOut.EnableDiagnostics)
{
Expression vref = new LiteralReference(taSite.Literal);
var fref = taSite.Literal as FieldRef;
var field = fref != null ? fref.FieldDesc : null;
if (field != null && field.HasAttribute <ActualTypeAttribute>())
{
var atype = field.QueryAttribute <ActualTypeAttribute>();
vref = IntrinsicFunctions.Cast(vref, vref.ResultType.CILType, atype.ActualType, true);
}
BodyBuilder.ReportLine(taSite.Literal.Name + " changed to ", vref);
}
}
BodyBuilder.EndIf();
}
if (needRead)
{
if (isBool)
{
BodyBuilder.If(lrVar);
{
BodyBuilder.If(lrVar);
BodyBuilder.Store(srDataOut, lr1);
}
BodyBuilder.Else();
{
BodyBuilder.Store(srDataOut, lr0);
}
BodyBuilder.EndIf();
}
else
{
BodyBuilder.Store(srDataOut, convVar);
}
}
}
