public void CreateControlpath(FlowMatrix flowSpec, string procName) { int ncsteps = flowSpec.NumCSteps; string report = _mcd.ComputeEncoding(flowSpec, _maxSelWidth); _curCW = (SLVSignal)_binder.GetSignal <StdLogicVector>(EPortUsage.Default, "CurCW", null, StdLogicVector._0s(_mcd.CWWidth)); var clkInst = _binder.GetSignal <StdLogic>(EPortUsage.Clock, "Clk", null, '0'); if (_staged) { _mcd.CreateStagedDecoder(_binder, _curCW, (SLSignal)clkInst, _registered); } else { _mcd.CreateDecoder(_binder, _curCW); } CreateROM(ncsteps); for (int cstep = 0; cstep < ncsteps; cstep++) { var cw = _mcd.Encode(cstep, flowSpec.GetFlow(cstep)); _romIf.PreWrite(StdLogicVector.FromUInt((uint)cstep, _pc.Size), cw); } var syncTempl = new SyncTemplate(this); var syncFunc = syncTempl.GetAlgorithm(); _binder.CreateProcess(SystemSharp.Components.Process.EProcessKind.Triggered, syncFunc, clkInst.Descriptor); _host.Descriptor.GetDocumentation().Documents.Add(new Document(procName + "_HMA_report.txt", report)); }
private void BuildFlowMap() { _elseFlows = new Dictionary <SignalRef, Flow>(); _enablingStatesMap = new Dictionary <Flow, List <object> >(); foreach (Flow flow in _flowSpec.NeutralFlow.Flows) { if (FlowMatrix.IsDontCareFlow(flow)) { var zflow = FlowMatrix.AsDontCareFlow((ValueFlow)flow, StdLogic.Z); _elseFlows[flow.Target] = zflow; } else { NonTristateTargets.Add(flow.Target); } } Array stateValues = _cpb._stateSignal.Descriptor.ElementType.CILType.GetEnumValues(); for (int cstep = 0; cstep < stateValues.Length; cstep++) { var state = stateValues.GetValue(cstep); var pflow = _flowSpec.GetFlow(cstep); foreach (var flow in pflow.Flows) { if (!_enablingStatesMap.ContainsKey(flow)) { _enablingStatesMap[flow] = new List <object>(); } _enablingStatesMap[flow].Add(state); } } }
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 void Encode(int cstep, ParFlow pflow, ref StdLogicVector cw) { foreach (var flow in pflow.Flows) { if (FlowMatrix.IsDontCareFlow(flow)) { continue; } var vflow = flow as ValueFlow; if (vflow != null) { int offs = _vfc.GetValueWordOffset(flow.Target); var ser = Marshal.SerializeForHW(vflow.Value); cw[offs + ser.Size - 1, offs] = ser; } } if (SelWidth <= 0) { return; } int symbol = _encFlow.EncodedSymbols[cstep]; if (symbol == 0) { symbol = 1; } uint index = (uint)(symbol - 1); cw[SelOffset + SelWidth - 1, SelOffset] = StdLogicVector.FromUInt(index, SelWidth); }
private void CreateStagedInterconnect(FlowMatrix flowSpec, FlowMatrix detailedFlow) { flowSpec.Transitize(); detailedFlow.AddNeutral(flowSpec.NeutralFlow); var tflows = flowSpec.GetTimedFlows(); var grouped = tflows.GroupBy(tf => tf.Target); foreach (var group in grouped) { var net = ConstructNetwork(group.Key, group); foreach (var tflow in net) { var tsf = tflow as TimedSignalFlow; var tvf = tflow as TimedValueFlow; if (tsf != null) { detailedFlow.Add((int)tflow.Time, new SignalFlow(tsf.Source, tsf.Target)); } else { detailedFlow.Add((int)tflow.Time, new ValueFlow(tvf.Value, tvf.Target)); } } } for (int i = 0; i < _stageInSignals.Count; i++) { detailedFlow.AddNeutral(new SignalFlow( _stageOutSignals[i].ToSignalRef(SignalRef.EReferencedProperty.Cur), _stageInSignals[i].ToSignalRef(SignalRef.EReferencedProperty.Next))); } }
public void CreateInterconnect(FlowMatrix flowSpec, FlowMatrix detailedFlow) { var temp = new FlowMatrix(); CreateStagedInterconnect(flowSpec, temp); InstantiateControlLogic(); _hcib.CreateInterconnect(temp, detailedFlow); }
public void CreateInterconnect(FlowMatrix flowSpec, FlowMatrix detailedFlow) { _flowSpec = flowSpec; _realFlow = detailedFlow; _flowSpec.Transitize(); InstantiateControlLogic(); AssembleFlowMatrix(); }
public FUDriveTemplate( TristateBusFSMControlpathBuilder cpb, FlowMatrix flowSpec, IEnumerable <SignalRef> nonTristateTargets) { _cpb = cpb; _flowSpec = flowSpec; _nonTristateTargets = new HashSet <SignalRef>(nonTristateTargets); }
public void CreateControlpath(FlowMatrix flowSpec, string procName) { flowSpec.ReplaceDontCares(); var sens = flowSpec.FlowSources.Select(sr => sr.Desc) .Concat(Enumerable.Repeat((ISignalOrPortDescriptor)_stateSignal.Descriptor, 1)) .Distinct(); var fudTempl = new FUDriveTemplate(this, flowSpec); var fudFunc = fudTempl.GetAlgorithm(); _binder.CreateProcess(SystemSharp.Components.Process.EProcessKind.Triggered, fudFunc, sens.ToArray()); _host.Descriptor.GetDocumentation().Documents.Add(new Document(procName + "_FSM_report.txt", flowSpec.GetMUXReport())); }
public void AddFlow(ParFlow pflow) { var vflows = pflow.Flows.Where(f => f is ValueFlow && !FlowMatrix.IsDontCareFlow(f)); _flowList.Add(new ParFlow(vflows)); foreach (var f in vflows) { var vflow = (ValueFlow)f; int width = Marshal.SerializeForHW(vflow.Value).Size; _widthMap[f.Target] = width; } }
public void CreateInterconnect(FlowMatrix flowSpec, FlowMatrix detailedFlow) { _flowSpec = flowSpec; _detailedFlow = detailedFlow; _flowSpec.Transitize(); Init(); ComputeLifetimes(); DoClustering(); DoMemoryClustering(); InstantiateControlLogic(); AssembleFlowMatrix(); VerifyResult(); }
public void CreateControlpath(FlowMatrix flowSpec, string procName) { var sens = flowSpec.FlowSources.Select(sr => sr.Desc) .Concat(Enumerable.Repeat((ISignalOrPortDescriptor)_stateSignal.Descriptor, 1)) .Distinct(); var tscTempl = new TristateConcTemplate(this, flowSpec); var tscFunc = tscTempl.GetAlgorithm(); _binder.CreateProcess(SystemSharp.Components.Process.EProcessKind.Triggered, tscFunc, sens.ToArray()); var fudTempl = new FUDriveTemplate(this, flowSpec, tscTempl.NonTristateTargets); var fudFunc = fudTempl.GetAlgorithm(); _binder.CreateProcess(SystemSharp.Components.Process.EProcessKind.Triggered, fudFunc, sens.ToArray()); }
public EncodedFlow(List <Flow> flows, int order) { Contract.Requires(flows != null && flows.Any()); Contract.Requires(flows.All(f => f.Target.Equals(flows.First().Target))); Targets = new SignalRef[] { flows.First().Target }; EncodedSymbols = new int[flows.Count]; Order = order; _bwdEnc = new List <ParFlow>(); int i = 0; foreach (var flow in flows) { int sym = 0; if (!FlowMatrix.IsDontCareFlow(flow)) { var vflow = flow as ValueFlow; Flow cflow; if (vflow != null) { cflow = FlowMatrix.AsDontCareFlow(vflow); } else { cflow = flow; } var cpflow = new ParFlow(new Flow[] { cflow }); if (!_fwdEnc.TryGetValue(cpflow, out sym)) { sym = ++NumSymbols; _fwdEnc[cpflow] = sym; _bwdEnc.Add(new ParFlow(new Flow[] { cflow })); } } EncodedSymbols[i] = sym; i++; } if (_bwdEnc.Count == 0) { var dummy = new ParFlow(); _bwdEnc.Add(dummy); _fwdEnc[dummy] = 1; NumSymbols = 1; } }
public void CreateInterconnect(FlowMatrix flowSpec, FlowMatrix detailedFlow) { flowSpec.Transitize(); var tflows = flowSpec.GetTimedFlows(); var sflows = tflows .Select(tf => tf as TimedSignalFlow) .Where(tf => tf != null); SlimMux <int, int, TimedSignalFlow> .ConstructInterconnect(_smih, sflows); var pipeen = _smih.ComputePipeEnMatrix(flowSpec.NumCSteps); var pipes = _smih.InstantiatePipes(); int idx = 0; foreach (RegPipe rp in pipes) { string id = "icpipe" + idx; _host.Descriptor.AddChild(rp.Descriptor, id); ++idx; } var pflows = _smih.ToFlow(flowSpec.NumCSteps, flowSpec.NeutralFlow, pipeen); var vflows = tflows .Select(tf => tf as TimedValueFlow) .Where(tf => tf != null); detailedFlow.AddNeutral(flowSpec.NeutralFlow); foreach (var vf in vflows) { detailedFlow.Add((int)vf.Time, new ValueFlow(vf.Value, vf.Target)); } int cstep = 0; foreach (var pf in pflows) { detailedFlow.Add(cstep, pf); cstep++; } _host.Descriptor.GetDocumentation().Documents.Add( new Document("SlimMuxInterconnectGraph.dotty", _smih.GetInterconnectGraphForDotty())); }
public void CreateInterconnect(FlowMatrix flowSpec, FlowMatrix detailedFlow) { flowSpec.Transitize(); var tflows = flowSpec.GetTimedFlows(); var sflows = tflows .Select(tf => tf as TimedSignalFlow) .Where(tf => tf != null); SlimMux<int, int, TimedSignalFlow>.ConstructInterconnect(_smih, sflows); var pipeen = _smih.ComputePipeEnMatrix(flowSpec.NumCSteps); var pipes = _smih.InstantiatePipes(); int idx = 0; foreach (RegPipe rp in pipes) { string id = "icpipe" + idx; _host.Descriptor.AddChild(rp.Descriptor, id); ++idx; } var pflows = _smih.ToFlow(flowSpec.NumCSteps, flowSpec.NeutralFlow, pipeen); var vflows = tflows .Select(tf => tf as TimedValueFlow) .Where(tf => tf != null); detailedFlow.AddNeutral(flowSpec.NeutralFlow); foreach (var vf in vflows) { detailedFlow.Add((int)vf.Time, new ValueFlow(vf.Value, vf.Target)); } int cstep = 0; foreach (var pf in pflows) { detailedFlow.Add(cstep, pf); cstep++; } _host.Descriptor.GetDocumentation().Documents.Add( new Document("SlimMuxInterconnectGraph.dotty", _smih.GetInterconnectGraphForDotty())); }
public TristateConcTemplate(TristateBusFSMControlpathBuilder cpb, FlowMatrix flowSpec) { _cpb = cpb; _flowSpec = flowSpec; NonTristateTargets = new List<SignalRef>(); }
public FUDriveTemplate( TristateBusFSMControlpathBuilder cpb, FlowMatrix flowSpec, IEnumerable<SignalRef> nonTristateTargets) { _cpb = cpb; _flowSpec = flowSpec; _nonTristateTargets = new HashSet<SignalRef>(nonTristateTargets); }
public string ComputeEncoding(FlowMatrix flowSpec, int maxSelWidth = 6) { var sb = new StringBuilder(); sb.AppendLine("Control word encoding report"); sb.AppendFormat(" Number of c-steps: {0}", flowSpec.NumCSteps); sb.AppendLine(); sb.AppendFormat(" Maximum LUT inputs: {0}", maxSelWidth); sb.AppendLine(); FlowSpec = flowSpec; var flowMap = new Dictionary <SignalRef, List <Flow> >(); var neutralFlow = flowSpec.NeutralFlow; _vcf.AddFlow(neutralFlow); for (int i = 0; i < flowSpec.NumCSteps; i++) { var pflow = flowSpec.GetFlow(i); var nflow = new ParFlow(neutralFlow); nflow.Integrate(pflow); _vcf.AddFlow(nflow); foreach (var flow in nflow.Flows) { List <Flow> flows; if (!flowMap.TryGetValue(flow.Target, out flows)) { flows = new List <Flow>(); flowMap[flow.Target] = flows; } flows.Add(flow); } } _vcf.Encode(); var startTime = DateTime.Now; var encFlows = flowMap.Values .Select((l, i) => new EncodedFlow(l, i)).ToArray(); var uncompressedMuxBits = encFlows.Sum(ef => MathExt.CeilLog2(ef.NumSymbols)); sb.AppendFormat(" Uncompressed CW: {0} MUX bits + {1} value bits", uncompressedMuxBits, _vcf.GetUncompressedValueWordWidth()); sb.AppendLine(); int numTargets = encFlows.Length; var mergeCandidates = new List <Tuple <int, int, MergedFlow> >(); var indices = new SortedSet <int>(Enumerable.Range(0, numTargets)); var curGen = (EncodedFlow[])encFlows.Clone(); bool mergedAny; var nextCandidates = new List <Tuple <int, int, MergedFlow> >(); do { foreach (int i in indices) { if (curGen[i].NumSymbols <= 1) { continue; } var upview = indices.GetViewBetween(i + 1, numTargets); foreach (int j in upview) { if (curGen[j].NumSymbols <= 1) { continue; } var mergedFlow = new MergedFlow(curGen[i], curGen[j]); mergeCandidates.Add(Tuple.Create(i, j, mergedFlow)); } } var orderedMergeCandidates = mergeCandidates.OrderByDescending(t => t.Item3.Score); var nextGen = (EncodedFlow[])curGen.Clone(); var mergedIndices = new HashSet <int>(); var mergedLowIndices = new SortedSet <int>(); var mergedHiIndices = new HashSet <int>(); mergedAny = false; foreach (var tup in orderedMergeCandidates) { Debug.Assert(tup.Item2 > tup.Item1); var mergedFlow = tup.Item3; if (mergedFlow.Score == 0.0) { break; } int selWidth = MathExt.CeilLog2(mergedFlow.NumSymbols); if (selWidth > maxSelWidth) { continue; } if (mergedIndices.Contains(tup.Item1) || mergedIndices.Contains(tup.Item2)) { continue; } mergedIndices.Add(tup.Item1); mergedIndices.Add(tup.Item2); mergedLowIndices.Add(tup.Item1); mergedHiIndices.Add(tup.Item2); indices.Remove(tup.Item2); mergedFlow.Realize(); Debug.Assert(nextGen[tup.Item1].Targets.All(t => mergedFlow.Targets.Contains(t))); Debug.Assert(nextGen[tup.Item2].Targets.All(t => mergedFlow.Targets.Contains(t))); nextGen[tup.Item1] = mergedFlow; mergedAny = true; } nextCandidates.Clear(); curGen = nextGen; mergeCandidates.Clear(); mergeCandidates.AddRange(nextCandidates); }while (mergedAny); _strings = indices.Select(i => new MicroString(curGen[i], _vcf)).ToArray(); // Verification var coveredTargets = _strings.SelectMany(s => s.Targets); var allTargets = encFlows.SelectMany(f => f.Targets); var isect0 = coveredTargets.Except(allTargets); var isect1 = allTargets.Except(coveredTargets); Debug.Assert(!isect0.Any()); Debug.Assert(!isect1.Any()); // int offset = _vcf.ValueWordWidth; int order = 0; foreach (var ms in _strings) { ms.SelOffset = offset; ms.Order = order; offset += ms.SelWidth; order++; } CWWidth = offset; var stopTime = DateTime.Now; var runTime = stopTime - startTime; sb.AppendFormat(" Compressed CW: {0} MUX bits + {1} value bits", offset - _vcf.ValueWordWidth, _vcf.ValueWordWidth); sb.AppendLine(); sb.AppendFormat(" Maximum LUT inputs: {0}", _strings.Max(s => s.SelWidth)); sb.AppendFormat(" Running time: {0} ms", runTime.TotalMilliseconds); sb.AppendLine(); sb.AppendLine(); sb.AppendLine("Number of MUX inputs; Number of occurences"); var histo = _strings.GroupBy(s => s.SelWidth) .OrderByDescending(grp => grp.Key); foreach (var grp in histo) { sb.AppendFormat("{0}; {1}", grp.Key, grp.Count()); sb.AppendLine(); } return(sb.ToString()); }
public FUDriveTemplate(FSMControlpathBuilder cpb, FlowMatrix flowSpec) { _cpb = cpb; _flowSpec = flowSpec; }
public void Encode() { // This is a simple, inefficient greedy heuristic which essentially finds maximal cliques // within the graph of mutually exclusive signal targets. var mutexSet = new HashSet <Tuple <SignalRef, SignalRef> >(); foreach (var pflow in _flowList) { var flows = pflow.Flows.ToArray(); for (int i = 0; i < flows.Length; i++) { for (int j = 0; j < flows.Length; j++) { var vf0 = (ValueFlow)flows[i]; var vf1 = (ValueFlow)flows[j]; if (!FlowMatrix.IsDontCareFlow(vf0) && !FlowMatrix.IsDontCareFlow(vf1) && !vf0.Value.Equals(vf1.Value)) { mutexSet.Add(Tuple.Create(vf0.Target, vf1.Target)); } } } } var order = _widthMap.OrderByDescending(kvp => kvp.Value).Select(kvp => kvp.Key); var list = new LinkedList <SignalRef>(order); int curOffset = 0; while (list.First != null) { var lln = list.First; var curGroup = new HashSet <SignalRef>(); curGroup.Add(lln.Value); int width = _widthMap[lln.Value]; _offsetMap[lln.Value] = curOffset; var next = lln.Next; list.Remove(lln); lln = next; while (lln != null) { bool found = true; foreach (var elem in curGroup) { if (mutexSet.Contains(Tuple.Create(elem, lln.Value))) { found = false; break; } } if (found) { curGroup.Add(lln.Value); _offsetMap[lln.Value] = curOffset; next = lln.Next; list.Remove(lln); lln = next; } else { lln = lln.Next; } } curOffset += width; } ValueWordWidth = curOffset; }
public TristateConcTemplate(TristateBusFSMControlpathBuilder cpb, FlowMatrix flowSpec) { _cpb = cpb; _flowSpec = flowSpec; NonTristateTargets = new List <SignalRef>(); }
private void CreateStagedInterconnect(FlowMatrix flowSpec, FlowMatrix detailedFlow) { flowSpec.Transitize(); detailedFlow.AddNeutral(flowSpec.NeutralFlow); var tflows = flowSpec.GetTimedFlows(); var grouped = tflows.GroupBy(tf => tf.Target); foreach (var group in grouped) { var net = ConstructNetwork(group.Key, group); foreach (var tflow in net) { var tsf = tflow as TimedSignalFlow; var tvf = tflow as TimedValueFlow; if (tsf != null) detailedFlow.Add((int)tflow.Time, new SignalFlow(tsf.Source, tsf.Target)); else detailedFlow.Add((int)tflow.Time, new ValueFlow(tvf.Value, tvf.Target)); } } for (int i = 0; i < _stageInSignals.Count; i++) { detailedFlow.AddNeutral(new SignalFlow( _stageOutSignals[i].ToSignalRef(SignalRef.EReferencedProperty.Cur), _stageInSignals[i].ToSignalRef(SignalRef.EReferencedProperty.Next))); } }
public string ComputeEncoding(FlowMatrix flowSpec, int maxSelWidth = 6) { var sb = new StringBuilder(); sb.AppendLine("Control word encoding report"); sb.AppendFormat(" Number of c-steps: {0}", flowSpec.NumCSteps); sb.AppendLine(); sb.AppendFormat(" Maximum LUT inputs: {0}", maxSelWidth); sb.AppendLine(); FlowSpec = flowSpec; var flowMap = new Dictionary<SignalRef, List<Flow>>(); var neutralFlow = flowSpec.NeutralFlow; _vcf.AddFlow(neutralFlow); for (int i = 0; i < flowSpec.NumCSteps; i++) { var pflow = flowSpec.GetFlow(i); var nflow = new ParFlow(neutralFlow); nflow.Integrate(pflow); _vcf.AddFlow(nflow); foreach (var flow in nflow.Flows) { List<Flow> flows; if (!flowMap.TryGetValue(flow.Target, out flows)) { flows = new List<Flow>(); flowMap[flow.Target] = flows; } flows.Add(flow); } } _vcf.Encode(); var startTime = DateTime.Now; var encFlows = flowMap.Values .Select((l, i) => new EncodedFlow(l, i)).ToArray(); var uncompressedMuxBits = encFlows.Sum(ef => MathExt.CeilLog2(ef.NumSymbols)); sb.AppendFormat(" Uncompressed CW: {0} MUX bits + {1} value bits", uncompressedMuxBits, _vcf.GetUncompressedValueWordWidth()); sb.AppendLine(); int numTargets = encFlows.Length; var mergeCandidates = new List<Tuple<int, int, MergedFlow>>(); var indices = new SortedSet<int>(Enumerable.Range(0, numTargets)); var curGen = (EncodedFlow[])encFlows.Clone(); bool mergedAny; var nextCandidates = new List<Tuple<int, int, MergedFlow>>(); do { foreach (int i in indices) { if (curGen[i].NumSymbols <= 1) continue; var upview = indices.GetViewBetween(i + 1, numTargets); foreach (int j in upview) { if (curGen[j].NumSymbols <= 1) continue; var mergedFlow = new MergedFlow(curGen[i], curGen[j]); mergeCandidates.Add(Tuple.Create(i, j, mergedFlow)); } } var orderedMergeCandidates = mergeCandidates.OrderByDescending(t => t.Item3.Score); var nextGen = (EncodedFlow[])curGen.Clone(); var mergedIndices = new HashSet<int>(); var mergedLowIndices = new SortedSet<int>(); var mergedHiIndices = new HashSet<int>(); mergedAny = false; foreach (var tup in orderedMergeCandidates) { Debug.Assert(tup.Item2 > tup.Item1); var mergedFlow = tup.Item3; if (mergedFlow.Score == 0.0) break; int selWidth = MathExt.CeilLog2(mergedFlow.NumSymbols); if (selWidth > maxSelWidth) continue; if (mergedIndices.Contains(tup.Item1) || mergedIndices.Contains(tup.Item2)) continue; mergedIndices.Add(tup.Item1); mergedIndices.Add(tup.Item2); mergedLowIndices.Add(tup.Item1); mergedHiIndices.Add(tup.Item2); indices.Remove(tup.Item2); mergedFlow.Realize(); Debug.Assert(nextGen[tup.Item1].Targets.All(t => mergedFlow.Targets.Contains(t))); Debug.Assert(nextGen[tup.Item2].Targets.All(t => mergedFlow.Targets.Contains(t))); nextGen[tup.Item1] = mergedFlow; mergedAny = true; } nextCandidates.Clear(); curGen = nextGen; mergeCandidates.Clear(); mergeCandidates.AddRange(nextCandidates); } while (mergedAny); _strings = indices.Select(i => new MicroString(curGen[i], _vcf)).ToArray(); // Verification var coveredTargets = _strings.SelectMany(s => s.Targets); var allTargets = encFlows.SelectMany(f => f.Targets); var isect0 = coveredTargets.Except(allTargets); var isect1 = allTargets.Except(coveredTargets); Debug.Assert(!isect0.Any()); Debug.Assert(!isect1.Any()); // int offset = _vcf.ValueWordWidth; int order = 0; foreach (var ms in _strings) { ms.SelOffset = offset; ms.Order = order; offset += ms.SelWidth; order++; } CWWidth = offset; var stopTime = DateTime.Now; var runTime = stopTime - startTime; sb.AppendFormat(" Compressed CW: {0} MUX bits + {1} value bits", offset - _vcf.ValueWordWidth, _vcf.ValueWordWidth); sb.AppendLine(); sb.AppendFormat(" Maximum LUT inputs: {0}", _strings.Max(s => s.SelWidth)); sb.AppendFormat(" Running time: {0} ms", runTime.TotalMilliseconds); sb.AppendLine(); sb.AppendLine(); sb.AppendLine("Number of MUX inputs; Number of occurences"); var histo = _strings.GroupBy(s => s.SelWidth) .OrderByDescending(grp => grp.Key); foreach (var grp in histo) { sb.AppendFormat("{0}; {1}", grp.Key, grp.Count()); sb.AppendLine(); } return sb.ToString(); }
public IEnumerable <ParFlow> ToFlow(int numCsteps, ParFlow neutralFlow, bool[,] pipeEnMatrix) { int muxCount = _pipeInSignals.Count; int[,] flowMatrix = new int[numCsteps, muxCount]; // 1st pass: set some arbitrary MUX selection for (int i = 0; i < numCsteps; i++) { for (int j = 0; j < muxCount; j++) { if (_preds[j].Any()) { flowMatrix[i, j] = _preds[j].First(); } else { flowMatrix[i, j] = -1; } } } // 2nd pass: reset MUX selection whenever neutral flow requires // some value transfer which is not "don't care" foreach (var flow in neutralFlow.Flows) { if (FlowMatrix.IsDontCareFlow(flow) || !_signal2Idx.IsCached(flow.Target)) { continue; } int idx = _signal2Idx[flow.Target]; for (int i = 0; i < numCsteps; i++) { flowMatrix[i, idx] = -1; } } // 3rd pass: transfer MUX reservations to matrix for (int i = 0; i < _resTable.Count; i++) { var rmap = _resTable[i]; var pi = _pipes[i]; foreach (var kvp in rmap) { flowMatrix[kvp.Key + pi.delay, pi.sink] = i; } } var pipeen = pipeEnMatrix; // last pass: convert to flows for (int i = 0; i < numCsteps; i++) { var flows = new List <Flow>(); for (int j = 0; j < muxCount; j++) { int k = flowMatrix[i, j]; if (k >= 0) { flows.Add( new SignalFlow( _pipeOutSignals[k].ToSignalRef(SignalRef.EReferencedProperty.Cur), _pipeInSignals[j].ToSignalRef(SignalRef.EReferencedProperty.Next))); } } for (int pipe = 0; pipe < _pipes.Count; pipe++) { if (!_pipes[pipe].useEn) { continue; } flows.Add( new ValueFlow( pipeen[i, pipe] ? StdLogic._1 : StdLogic._0, _pipeEnSignals[pipe].ToSignalRef(SignalRef.EReferencedProperty.Next))); } yield return(new ParFlow(flows)); } }
/// <summary> /// Executes the HLS design flow. /// </summary> /// <param name="design">the design</param> /// <param name="host">the hosting component</param> /// <param name="proc">the process being subject to HLS</param> /// <param name="targetProject">the target project</param> /// <remarks>Inside the hosting component, the process will be replaced by the synthesized hardware.</remarks> public void Execute(DesignContext design, Component host, ProcessDescriptor proc, IProject targetProject) { Contract.Requires <ArgumentNullException>(design != null); Contract.Requires <ArgumentNullException>(host != null); Contract.Requires <ArgumentNullException>(proc != null); Contract.Requires <ArgumentNullException>(targetProject != null); design.CurrentProcess = proc.Instance; var clk = proc.Sensitivity[0]; SignalBase clkI; var sdClk = clk as SignalDescriptor; if (sdClk == null) { clkI = ((SignalDescriptor)((PortDescriptor)clk).BoundSignal).Instance; } else { clkI = sdClk.Instance; } var state = new HLSState(this, design, host, proc, targetProject); proc.AddAttribute(state); if (_beginHLS != null) { _beginHLS(state); } var dpb = new DefaultDatapathBuilder(host, clkI, proc.Name); state.InterconnectBuilder = InterconnectBuilder.Create(host, dpb.ICBinder); state.ControlpathBuilder = ControlPathBuilder.Create(host, dpb.FUBinder); state.ControlpathBuilder.PersonalizePlan(this); do { XILSFunction fnasm; if (!proc.HasAttribute <XILSFunction>()) { var func = proc.Implementation; IEnumerable <Function> inlinedFunctions; func = func.InlineCalls(out inlinedFunctions); if (ConvertFieldsToLocals) { Variable[] newLocals; func = func.ConvertFieldsToLocals(out newLocals); } state.PreprocessedFunction = func; fnasm = state.PreprocessedFunction.Compile(DefaultInstructionSet.Instance); } else { fnasm = proc.QueryAttribute <XILSFunction>(); } fnasm.SanityCheck(); state.XILSInput = fnasm; IList <XILSInstr> instrs = state.XILSInput.Instructions.ToList(); foreach (var rw in XILSTransformations) { instrs = rw.Rewrite(instrs); fnasm = new XILSFunction(fnasm.Name, fnasm.Arguments, fnasm.Locals, instrs.ToArray()); fnasm.SanityCheck(); } state.XILSTransformed = fnasm; XIL3Function fnasm3 = fnasm.ToXIL3(); state.XIL3Input = fnasm3; foreach (IXIL3Rewriter rw in XIL3Transformations) { fnasm3 = rw.Rewrite(fnasm3); fnasm3.SanityCheck(); } state.XIL3Transformed = fnasm3; state.NotifyProgress(EHLSProgress.Compiled); } while (state._repeat); if (state._cancel) { return; } SchedulingConstraints constraints; do { var xmm = new XILMapperManager(); foreach (var dpu in Enumerable.Reverse(XILMappers)) { xmm.AddMapper(dpu); } DesignContext.Push(); var xilsa = new XILSchedulingAdapter(state.XIL3Transformed, xmm, host, targetProject); if (AllocationPolicy != null) { xilsa.Allocator.Policy = AllocationPolicy.Create(); } if (_onFUCreated != null) { xilsa.Allocator.OnFUAllocation += _onFUCreated; } state.SchedulingAdapter = xilsa; state.NotifyProgress(EHLSProgress.AboutToSchedule); constraints = SchedulingConstraints; if (constraints == null) { if (proc.Implementation != null) { constraints = proc.Implementation.QueryAttribute <SchedulingConstraints>(); } if (constraints == null) { constraints = new SchedulingConstraints(); } } state.Constraints = constraints; if (constraints.MinimizeNumberOfFUs) { foreach (var instr in state.XIL3Transformed.Instructions) { xilsa.SetMaxFUAllocation(xilsa.IClass[instr], 1); } } Scheduler.Schedule(xilsa.CFG, constraints, xilsa); DesignContext.Pop(); state.NotifyProgress(EHLSProgress.Scheduled); } while (state._repeat); ComputeCStepsForBranchTargets(state.SchedulingAdapter); do { state.ControlpathBuilder.PrepareAllocation(state.SchedulingAdapter.ComputeCStepCount()); var flowSpec = state.SchedulingAdapter.Allocate(dpb); state.RawFlows = flowSpec; var realFlow = new FlowMatrix(); state.InterconnectBuilder.CreateInterconnect(flowSpec, realFlow); state.RealFlows = realFlow; state.NotifyProgress(EHLSProgress.InterconnectCreated); } while (state._repeat); if (state._cancel) { return; } Debug.Assert(state.RealFlows.FlowSources.All(sr => sr.Desc.Owner != null)); Debug.Assert(state.RealFlows.FlowTargets.All(sr => sr.Desc.Owner != null)); do { state.ControlpathBuilder.CreateControlpath(state.RealFlows, proc.Name); foreach (var prof in constraints.Profilers) { prof.ExtractFrom(state.XIL3Transformed, state.SchedulingAdapter); } state.NotifyProgress(EHLSProgress.ControlpathCreated); } while (state._repeat); if (state._cancel) { return; } }