Example #1
0
        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);
                    }
                }
            }
Example #3
0
 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));
     }
 }
Example #4
0
        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);
        }
Example #5
0
        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)));
            }
        }
Example #6
0
        public void CreateInterconnect(FlowMatrix flowSpec, FlowMatrix detailedFlow)
        {
            var temp = new FlowMatrix();

            CreateStagedInterconnect(flowSpec, temp);
            InstantiateControlLogic();
            _hcib.CreateInterconnect(temp, detailedFlow);
        }
Example #7
0
 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()));
        }
Example #10
0
        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;
            }
        }
Example #11
0
 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());
        }
Example #13
0
        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;
            }
        }
Example #14
0
        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 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 FUDriveTemplate(
     TristateBusFSMControlpathBuilder cpb, 
     FlowMatrix flowSpec,
     IEnumerable<SignalRef> nonTristateTargets)
 {
     _cpb = cpb;
     _flowSpec = flowSpec;
     _nonTristateTargets = new HashSet<SignalRef>(nonTristateTargets);
 }
Example #19
0
        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 FUDriveTemplate(FSMControlpathBuilder cpb, FlowMatrix flowSpec)
 {
     _cpb = cpb;
     _flowSpec = flowSpec;
 }
Example #22
0
        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>();
 }
Example #24
0
 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();
        }
Example #26
0
        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));
            }
        }
 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()));
 }
Example #28
0
 public void CreateInterconnect(FlowMatrix flowSpec, FlowMatrix detailedFlow)
 {
     var temp = new FlowMatrix();
     CreateStagedInterconnect(flowSpec, temp);
     InstantiateControlLogic();
     _hcib.CreateInterconnect(temp, detailedFlow);
 }
Example #29
0
        /// <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;
            }
        }