Esempio n. 1
0
        public void Compile(ProgramGraph graph, CompilerOutputInfo info)
        {
            if (!(info is ShaderOutputInfo))
            {
                return;
            }
            ShaderOutputInfo outputInfo = info as ShaderOutputInfo;

            RegisterDict = new Dictionary <string, int>();
            for (int i = 0; i < graph.getMaxDepth(); i++)
            {
                foreach (Vertex v in graph.getVerticesForLayer(i))
                {
                    foreach (NodeItem outputItem in v.Data.Items.Where(item => item.Output.Enabled))
                    {
                        if (outputItem.OutputData is ShaderTypes.sampler2D)
                        {
                            ShaderTypes.sampler2D Sampler = (ShaderTypes.sampler2D)outputItem.OutputData;
                            if (!RegisterDict.ContainsKey(Sampler.path))
                            {
                                RegisterDict.Add(Sampler.path, RegisterDict.Count);
                            }
                        }
                    }
                }
            }
            mCompiler = new HLSLCompiler(new Dictionary <object, string>(), RegisterDict);
            WritePostFxScript(outputInfo);
            if (mCompiler == null)
            {
                return;
            }
            mCompiler.Compile(graph, outputInfo);
        }
Esempio n. 2
0
        protected void CreateSingleLoop(
            ProgramGraph g, ValueNode ap, ValueNode bp, ValueNode s,
            ValueNode ap1, ValueNode bp1, ValueNode s1)
        {
            OperationNode[] o = new OperationNode[8];

            o[0] = new AddOperationNode();
            o[1] = new MulOperationNode();
            o[2] = new LoadOperationNode();
            o[3] = new AddOperationNode();
            o[4] = new LoadOperationNode();
            o[5] = new AddOperationNode();
            o[6] = new ConstOperationNode();
            o[7] = new ConstOperationNode();

            foreach (OperationNode op in o)
                g.AddNode(op);

            ValueNode[] v = new ValueNode[7];

            v[0] = new FloatRegisterNode();
            v[1] = new FloatRegisterNode();
            v[2] = new FloatRegisterNode();
            v[3] = new IntRegisterNode();
            v[4] = new IntRegisterNode();
            v[5] = new IntConstantNode(4);
            v[6] = new IntConstantNode(4);

            foreach (ValueNode val in v)
                g.AddNode(val);

            g.AddEdge(v[0], o[0]);
            g.AddEdge(s, o[0]);
            g.AddEdge(o[0], s1);
            g.AddEdge(v[1], o[1]);
            g.AddEdge(v[2], o[1]);
            g.AddEdge(o[1], v[0]);
            g.AddEdge(ap, o[2]);
            g.AddEdge(o[2], v[1]);
            g.AddEdge(ap, o[3]);
            g.AddEdge(v[3], o[3]);
            g.AddEdge(o[3], ap1);
            g.AddEdge(bp, o[4]);
            g.AddEdge(o[4], v[2]);
            g.AddEdge(bp, o[5]);
            g.AddEdge(v[4], o[5]);
            g.AddEdge(o[5], bp1);
            g.AddEdge(v[5], o[6]);
            g.AddEdge(o[6], v[3]);
            g.AddEdge(v[6], o[7]);
            g.AddEdge(o[7], v[4]);
        }
Esempio n. 3
0
        public ProgramGraph CreateUnrolledProgramGraph(int k)
        {
            ProgramGraph g = new ProgramGraph();

            ValueNode[] ap = new ValueNode[k + 1];
            ValueNode[] bp = new ValueNode[k + 1];
            ValueNode[] cp = new ValueNode[k + 1];

            for (int i = 0; i < k + 1; i++) {

                ap[i] = new TestRegisterNode("a[" + i + "]", Datatype.AddressValue);
                bp[i] = new TestRegisterNode("b[" + i + "]", Datatype.AddressValue);
                cp[i] = new TestRegisterNode("c[" + i + "]", Datatype.AddressValue);

                g.AddNode(ap[i]);
                g.AddNode(bp[i]);
                g.AddNode(cp[i]);
            }

            ValueNode k0 = new TestRegisterNode("k0", Datatype.FloatValue);
            ValueNode k1 = new TestRegisterNode("k1", Datatype.FloatValue);

            g.AddNode(k0);
            g.AddNode(k1);

            for (int i = 0; i < k; i++) {

                CreateSingleLoop(
                    g, ap[i], bp[i], cp[i], k0, k1,
                    ap[i + 1], bp[i + 1], cp[i + 1]);
            }

            g.InitInputValues();
            g.InitOutputValues();

            g.OutputValues.Add(k0);
            g.OutputValues.Add(k1);

            g.CyclicDependencies[ap[0]] = ap[k];
            g.CyclicDependencies[ap[k]] = ap[0];

            g.CyclicDependencies[bp[0]] = bp[k];
            g.CyclicDependencies[bp[k]] = bp[0];

            g.CyclicDependencies[cp[0]] = cp[k];
            g.CyclicDependencies[cp[k]] = cp[0];

            return g;
        }
Esempio n. 4
0
        public GACodeGeneratorTester(
            IMachineDescriptionProvider mdp,
            IProgramGraphProvider pgp, int k,
            GAInstructionSelectorConfiguration isConfig,
            GASchedulerConfiguration scConfig,
            TextWriter textWriter,
            TextWriter dataWriter)
        {
            machineDescription = mdp.CreateMachineDescription();
            programGraph = pgp.CreateUnrolledProgramGraph(k);

            codeGenerator = new GACodeGenerator(isConfig, scConfig);
            iSelector = codeGenerator.InstructionSelector;
            scheduler = codeGenerator.Scheduler;

            this.textWriter = textWriter;
            this.dataWriter = dataWriter;
        }
Esempio n. 5
0
        public void Compile(ProgramGraph graph, CompilerOutputInfo info)
        {
            currentDepth = 0;
            List <Vertex> inputVertices = graph.getVerticesForLayer(0);
            Vertex        main          = GetMainInput(inputVertices);

            if (main == null)
            {
                return;
            }
            InputDict = new Dictionary <object, string>();
            outStream = new StreamWriter(info.outputPath + info.outputFilename + ".hlsl");
            WriteInputHeaders(inputVertices);
            WriteFunctionHeader(main);
            for (int i = 0; i <= graph.getMaxDepth(); i++)
            {
                WriteLayer(graph.getVerticesForLayer(i));
            }
            currentDepth--;
            WriteLine("}", IndentType.Decrease);
            outStream.Close();
        }
Esempio n. 6
0
        public ProgramGraph CreateUnrolledProgramGraph(int k) {

            ProgramGraph g = new ProgramGraph();

            ValueNode[] ap = new ValueNode[k + 1];
            ValueNode[] bp = new ValueNode[k + 1];
            ValueNode[] s  = new ValueNode[k + 1];

            for (int i = 0; i < k + 1; i++) {

                ap[i] = new TestRegisterNode("a[" + i + "]", Datatype.AddressValue);
                bp[i] = new TestRegisterNode("b[" + i + "]", Datatype.AddressValue);
                s[i]  = new TestRegisterNode("s[" + i + "]", Datatype.FloatValue);

                g.AddNode(ap[i]);
                g.AddNode(bp[i]);
                g.AddNode(s[i]);
            }

            for (int i = 0; i < k; i++)
                CreateSingleLoop(
                    g, ap[i], bp[i], s[i], ap[i + 1], bp[i + 1], s[i + 1]);
            }
Esempio n. 7
0
        protected void CreateSingleLoop(
            ProgramGraph g, ValueNode xp, ValueNode yp, ValueNode x, ValueNode y,
            ValueNode c0, ValueNode c1, ValueNode c2, ValueNode xp1, ValueNode yp1,
            ValueNode x1, ValueNode y1)
        {
            OperationNode[] o = new OperationNode[11];

            o[0]  = new StoreOperationNode();
            o[1]  = new AddOperationNode();
            o[2]  = new AddOperationNode();
            o[3]  = new ConstOperationNode();
            o[4]  = new AddOperationNode();
            o[5]  = new MulOperationNode();
            o[6]  = new MulOperationNode();
            o[7]  = new MulOperationNode();
            o[8]  = new LoadOperationNode();
            o[9]  = new AddOperationNode();
            o[10] = new ConstOperationNode();

            foreach (OperationNode op in o)
                g.AddNode(op);

            ValueNode[] v = new ValueNode[9];

            v[0]  = new FloatMemoryNode(null);
            v[1]  = new IntRegisterNode();
            v[2]  = new FloatRegisterNode();
            v[3]  = new FloatRegisterNode();
            v[4]  = new IntConstantNode(4);
            v[5]  = new FloatRegisterNode();
            v[6]  = new FloatRegisterNode();
            v[7]  = new IntRegisterNode();
            v[8]  = new IntConstantNode(4);

            foreach (ValueNode val in v)
                g.AddNode(val);

            g.AddEdge(y1, o[0]);
            g.AddEdge(yp, o[0]);
            g.AddEdge(o[0], v[0]);
            g.AddEdge(yp, o[1]);
            g.AddEdge(v[1], o[1]);
            g.AddEdge(o[1], yp1);
            g.AddEdge(v[2], o[2]);
            g.AddEdge(v[3], o[2]);
            g.AddEdge(o[2], y1);
            g.AddEdge(v[4], o[3]);
            g.AddEdge(o[3], v[1]);
            g.AddEdge(v[5], o[4]);
            g.AddEdge(v[6], o[4]);
            g.AddEdge(o[4], v[2]);
            g.AddEdge(c2, o[5]);
            g.AddEdge(y, o[5]);
            g.AddEdge(o[5], v[3]);
            g.AddEdge(c1, o[6]);
            g.AddEdge(x, o[6]);
            g.AddEdge(o[6], v[5]);
            g.AddEdge(c0, o[7]);
            g.AddEdge(x1, o[7]);
            g.AddEdge(o[7], v[6]);
            g.AddEdge(xp, o[8]);
            g.AddEdge(o[8], x1);
            g.AddEdge(xp, o[9]);
            g.AddEdge(v[7], o[9]);
            g.AddEdge(o[9], xp1);
            g.AddEdge(v[8], o[10]);
            g.AddEdge(o[10], v[7]);
        }
Esempio n. 8
0
        public ProgramGraph CreateUnrolledProgramGraph(int k)
        {
            ProgramGraph g = new ProgramGraph();

            ValueNode[] xp = new ValueNode[k + 1];
            ValueNode[] yp = new ValueNode[k + 1];
            ValueNode[] y  = new ValueNode[k + 1];
            ValueNode[] x  = new ValueNode[k + 1];

            for (int i = 0; i < k + 1; i++) {

                xp[i] = new TestRegisterNode("xp[" + i + "]", Datatype.AddressValue);
                yp[i] = new TestRegisterNode("yp[" + i + "]", Datatype.AddressValue);

                y[i] = new TestRegisterNode("y[" + i + "]", Datatype.FloatValue);
                x[i] = new TestRegisterNode("x[" + i + "]", Datatype.FloatValue);

                g.AddNode(xp[i]);
                g.AddNode(yp[i]);
                g.AddNode(x[i]);
                g.AddNode(y[i]);
            }

            ValueNode pc0 = new FloatMemoryNode("c0");
            ValueNode pc1 = new FloatMemoryNode("c1");
            ValueNode pc2 = new FloatMemoryNode("c2");

            OperationNode lc0 = new LoadOperationNode();
            OperationNode lc1 = new LoadOperationNode();
            OperationNode lc2 = new LoadOperationNode();

            ValueNode c0 = new FloatRegisterNode();
            ValueNode c1 = new FloatRegisterNode();
            ValueNode c2 = new FloatRegisterNode();

            g.AddNode(pc0); g.AddNode(pc1); g.AddNode(pc2);
            g.AddNode(lc0); g.AddNode(lc1); g.AddNode(lc2);
            g.AddNode(c0);  g.AddNode(c1);  g.AddNode(c2);

            g.AddEdge(pc0, lc0); g.AddEdge(lc0, c0);
            g.AddEdge(pc1, lc1); g.AddEdge(lc1, c1);
            g.AddEdge(pc2, lc2); g.AddEdge(lc2, c2);

            for (int i = 0; i < k; i++) {

                CreateSingleLoop(
                    g, xp[i], yp[i], x[i], y[i], c0, c1, c2,
                    xp[i + 1], yp[i + 1], x[i + 1], y[i + 1]);
            }

            g.InitInputValues();
            g.InitOutputValues();

            g.OutputValues.Add(x[k]);
            g.OutputValues.Add(y[k]);

            x[k].OutputFlag = true;
            y[k].OutputFlag = true;

            g.CyclicDependencies[xp[0]] = xp[k];
            g.CyclicDependencies[xp[k]] = xp[0];

            g.CyclicDependencies[yp[0]] = yp[k];
            g.CyclicDependencies[yp[k]] = yp[0];

            g.CyclicDependencies[y[0]] = y[k];
            g.CyclicDependencies[y[k]] = y[0];

            g.CyclicDependencies[x[0]] = x[k];
            g.CyclicDependencies[x[k]] = x[0];

            return g;
        }
Esempio n. 9
0
        protected void CreateSingleFilterLoop(
            ProgramGraph g, ValueNode x, ValueNode x0, ValueNode x1,
            ValueNode c0, ValueNode c1, ValueNode c2, ValueNode c3, ValueNode c4,
            ValueNode z0, ValueNode z1, ValueNode y)
        {
            OperationNode[] o = new OperationNode[13];

            o[0]  = new AddOperationNode();
            o[1]  = new MulOperationNode();
            o[2]  = new AddOperationNode();
            o[3]  = new AddOperationNode();
            o[4]  = new MulOperationNode();
            o[5]  = new AddOperationNode();
            o[6]  = new AddOperationNode();
            o[7]  = new AddOperationNode();
            o[8]  = new MulOperationNode();
            o[9]  = new MulOperationNode();
            o[10] = new MulOperationNode();
            o[11] = new AddOperationNode();
            o[12] = new AddOperationNode();

            foreach (OperationNode opNode in o)
                g.AddNode(opNode);

            ValueNode[] v = new ValueNode[10];

            for (int i = 0; i < v.Length; i++)
                v[i] = new FloatRegisterNode();

            foreach (ValueNode vNode in v)
                g.AddNode(vNode);

            g.AddEdge(x,     o[0]);
            g.AddEdge(x0,    o[0]);
            g.AddEdge(o[0],  v[0]);
            g.AddEdge(c0,    o[1]);
            g.AddEdge(v[0],  o[1]);
            g.AddEdge(o[1],  v[1]);
            g.AddEdge(x,     o[2]);
            g.AddEdge(v[1],  o[2]);
            g.AddEdge(o[2],  v[2]);
            g.AddEdge(v[2],  o[3]);
            g.AddEdge(x1,    o[3]);
            g.AddEdge(o[3],  v[3]);
            g.AddEdge(c1,    o[4]);
            g.AddEdge(v[3],  o[4]);
            g.AddEdge(o[4],  v[4]);
            g.AddEdge(v[2],  o[5]);
            g.AddEdge(v[4],  o[5]);
            g.AddEdge(o[5],  z1);
            g.AddEdge(v[1],  o[6]);
            g.AddEdge(x0,    o[6]);
            g.AddEdge(o[6],  v[5]);
            g.AddEdge(v[4],  o[7]);
            g.AddEdge(x1,    o[7]);
            g.AddEdge(o[7],  z0);
            g.AddEdge(v[5],  o[8]);
            g.AddEdge(c2,    o[8]);
            g.AddEdge(o[8],  v[6]);
            g.AddEdge(z0,    o[9]);
            g.AddEdge(c3,    o[9]);
            g.AddEdge(o[9],  v[7]);
            g.AddEdge(z1,    o[10]);
            g.AddEdge(c4,    o[10]);
            g.AddEdge(o[10], v[9]);
            g.AddEdge(v[6],  o[11]);
            g.AddEdge(v[7],  o[11]);
            g.AddEdge(o[11], v[8]);
            g.AddEdge(v[8],  o[12]);
            g.AddEdge(v[9],  o[12]);
            g.AddEdge(o[12], y);
        }
Esempio n. 10
0
        public ProgramGraph CreateUnrolledProgramGraph(int k)
        {
            ProgramGraph g = new ProgramGraph();

            ValueNode[] px = new ValueNode[k + 1];
            ValueNode[] py = new ValueNode[k + 1];

            for (int i = 0; i < k + 1; i++) {

                px[i] = new TestRegisterNode("x[" + i + "]", Datatype.AddressValue);
                py[i] = new TestRegisterNode("y[" + i + "]", Datatype.AddressValue);

                g.AddNode(px[i]);
                g.AddNode(py[i]);
            }

            ValueNode[] x = new ValueNode[k];
            ValueNode[] y = new ValueNode[k];

            for (int i = 0; i < k; i++) {

                x[i] = new FloatRegisterNode();
                y[i] = new FloatRegisterNode();

                g.AddNode(x[i]);
                g.AddNode(y[i]);
            }

            ValueNode[] x0 = new ValueNode[k + 1];
            ValueNode[] x1 = new ValueNode[k + 1];

            for (int i = 0; i < k + 1; i++) {

                x0[i] = new TestRegisterNode("x0[" + i + "]", Datatype.FloatValue);
                x1[i] = new TestRegisterNode("x1[" + i + "]", Datatype.FloatValue);

                g.AddNode(x0[i]);
                g.AddNode(x1[i]);
            }

            ValueNode pc0 = new FloatMemoryNode("c0");
            ValueNode pc1 = new FloatMemoryNode("c1");
            ValueNode pc2 = new FloatMemoryNode("c2");
            ValueNode pc3 = new FloatMemoryNode("c3");
            ValueNode pc4 = new FloatMemoryNode("c4");

            OperationNode lc0 = new LoadOperationNode();
            OperationNode lc1 = new LoadOperationNode();
            OperationNode lc2 = new LoadOperationNode();
            OperationNode lc3 = new LoadOperationNode();
            OperationNode lc4 = new LoadOperationNode();

            ValueNode c0 = new FloatRegisterNode();
            ValueNode c1 = new FloatRegisterNode();
            ValueNode c2 = new FloatRegisterNode();
            ValueNode c3 = new FloatRegisterNode();
            ValueNode c4 = new FloatRegisterNode();

            g.AddNode(pc0); g.AddNode(pc1); g.AddNode(pc2);
            g.AddNode(pc3); g.AddNode(pc4);

            g.AddNode(lc0); g.AddNode(lc1); g.AddNode(lc2);
            g.AddNode(lc3); g.AddNode(lc4);

            g.AddNode(c0); g.AddNode(c1); g.AddNode(c2);
            g.AddNode(c3); g.AddNode(c4);

            g.AddEdge(pc0, lc0); g.AddEdge(lc0, c0);
            g.AddEdge(pc1, lc1); g.AddEdge(lc1, c1);
            g.AddEdge(pc2, lc2); g.AddEdge(lc2, c2);
            g.AddEdge(pc3, lc3); g.AddEdge(lc3, c3);
            g.AddEdge(pc4, lc4); g.AddEdge(lc4, c4);

            for (int i = 0; i < k; i++) {

                CreateLoadIncGraph(
                    g, x[i], px[i], px[i + 1], 4);

                CreateStoreIncGraph(
                    g, y[i], py[i], py[i + 1], 4);

                CreateSingleFilterLoop(
                    g, x[i], x0[i], x1[i], c0, c1, c2, c3, c4,
                    x0[i + 1], x1[i + 1], y[i]);
            }

            g.InitInputValues();
            g.InitOutputValues();

            g.CyclicDependencies[x0[0]] = x0[k];
            g.CyclicDependencies[x0[k]] = x0[0];

            g.CyclicDependencies[x1[0]] = x1[k];
            g.CyclicDependencies[x1[k]] = x1[0];

            g.CyclicDependencies[px[0]] = px[k];
            g.CyclicDependencies[px[k]] = px[0];

            g.CyclicDependencies[py[0]] = py[k];
            g.CyclicDependencies[py[k]] = py[0];

            return g;
        }
Esempio n. 11
0
        protected void CreateSingleLoop(
            ProgramGraph g, ValueNode ap, ValueNode bp, ValueNode cp,
            ValueNode k0, ValueNode k1,
            ValueNode ap1, ValueNode bp1, ValueNode cp1)
        {
            OperationNode[] o = new OperationNode[12];

            o[0]  = new AddOperationNode();
            o[1]  = new MulOperationNode();
            o[2]  = new MulOperationNode();
            o[3]  = new LoadOperationNode();
            o[4]  = new AddOperationNode();
            o[5]  = new LoadOperationNode();
            o[6]  = new AddOperationNode();
            o[7]  = new ConstOperationNode();
            o[8]  = new ConstOperationNode();
            o[9]  = new StoreOperationNode();
            o[10] = new AddOperationNode();
            o[11] = new ConstOperationNode();

            foreach (OperationNode op in o)
                g.AddNode(op);

            ValueNode[] v = new ValueNode[12];

            v[0]  = new FloatRegisterNode();
            v[1]  = new FloatRegisterNode();
            v[2]  = new FloatRegisterNode();
            v[3]  = new FloatRegisterNode();
            v[4]  = new IntRegisterNode();
            v[5]  = new IntRegisterNode();
            v[6]  = new IntConstantNode(4);
            v[7]  = new IntConstantNode(4);
            v[8]  = new FloatRegisterNode();
            v[9]  = new FloatMemoryNode(null);
            v[10] = new IntRegisterNode();
            v[11] = new IntConstantNode(4);

            foreach (ValueNode val in v)
                g.AddNode(val);

            g.AddEdge(v[0], o[0]);
            g.AddEdge(v[1], o[0]);
            g.AddEdge(o[0], v[8]);
            g.AddEdge(v[2], o[1]);
            g.AddEdge(k0, o[1]);
            g.AddEdge(o[1], v[0]);
            g.AddEdge(v[3], o[2]);
            g.AddEdge(k1, o[2]);
            g.AddEdge(o[2], v[1]);
            g.AddEdge(ap, o[3]);
            g.AddEdge(o[3], v[2]);
            g.AddEdge(ap, o[4]);
            g.AddEdge(v[4], o[4]);
            g.AddEdge(o[4], ap1);
            g.AddEdge(bp, o[5]);
            g.AddEdge(o[5], v[3]);
            g.AddEdge(bp, o[6]);
            g.AddEdge(v[5], o[6]);
            g.AddEdge(o[6], bp1);
            g.AddEdge(v[6], o[7]);
            g.AddEdge(o[7], v[4]);
            g.AddEdge(v[7], o[8]);
            g.AddEdge(o[8], v[5]);
            g.AddEdge(v[8], o[9]);
            g.AddEdge(cp, o[9]);
            g.AddEdge(o[9], v[9]);
            g.AddEdge(cp, o[10]);
            g.AddEdge(v[10], o[10]);
            g.AddEdge(o[10], cp1);
            g.AddEdge(v[11], o[11]);
            g.AddEdge(o[11], v[10]);
        }
Esempio n. 12
0
        /// <summary>
        /// Populates the loop information.
        /// </summary>
        /// <param name="program">The given program.</param>
        private static void PopulateLoopInformation(Program program)
        {
            ProgramGraph graph = new ProgramGraph(program);

            BackEdges    = graph.BackEdges;
            LoopBarriers = new Dictionary <BackEdge, List <Barrier> >();

            foreach (BackEdge edge in graph.BackEdges)
            {
                List <ProgramNode> loopNodes  = graph.GetLoopNodes(edge);
                List <Block>       loopBlocks = loopNodes.Select(x => x.Block).ToList();

                IEnumerable <Barrier> barriers = Barriers.Values.Where(x => loopBlocks.Contains(x.Block));
                LoopBarriers.Add(edge, barriers.ToList());
            }

            foreach (Barrier barrier in Barriers.Values)
            {
                barrier.LoopDepth = LoopBarriers.Where(x => x.Value.Contains(barrier)).Count();
            }

            // consider barriers instrumented in the header node as a part of the loop
            // these barriers will not have a loop depth since they are outside the loop
            foreach (BackEdge edge in graph.BackEdges)
            {
                foreach (ProgramNode predecessor in edge.Destination.Predecessors)
                {
                    // ignore the other end of the back-edge
                    if (predecessor == edge.Source)
                    {
                        continue;
                    }

                    // identify the last thread-level and grid-level barrier in the predecessor
                    int?thread = null, grid = null;

                    int location = predecessor.Block.Cmds.Count - 1;
                    while (location >= 0)
                    {
                        if (predecessor.Block.Cmds[location] is CallCmd)
                        {
                            CallCmd command = predecessor.Block.Cmds[location] as CallCmd;
                            if (thread == null && command.callee.Contains("$bugle_barrier"))
                            {
                                thread = location;
                            }

                            if (grid == null && command.callee.Contains("bugle_grid_barrier"))
                            {
                                grid = location;
                            }
                        }

                        if (thread != null && grid != null)
                        {
                            break;
                        }
                        location = location - 1;
                    }

                    if (thread != null)
                    {
                        CallCmd command = predecessor.Block.Cmds[thread.Value] as CallCmd;
                        Barrier barrier = Barriers.Where(x => x.Value.Call == command).Select(x => x.Value).FirstOrDefault();
                        if (barrier != null && !LoopBarriers[edge].Contains(barrier))
                        {
                            LoopBarriers[edge].Add(barrier);
                        }
                    }

                    if (grid != null)
                    {
                        CallCmd command = predecessor.Block.Cmds[grid.Value] as CallCmd;
                        Barrier barrier = Barriers.Where(x => x.Value.Call == command).Select(x => x.Value).FirstOrDefault();
                        if (barrier != null && !LoopBarriers[edge].Contains(barrier))
                        {
                            LoopBarriers[edge].Add(barrier);
                        }
                    }
                }
            }
        }
Esempio n. 13
0
        public ProgramGraph CreateUnrolledProgramGraph(int k)
        {
            ProgramGraph g = new ProgramGraph();

            ValueNode[] ap = new ValueNode[k + 1];
            ValueNode[] bp = new ValueNode[k + 1];
            ValueNode[] s  = new ValueNode[k + 1];

            ValueNode[] cp = new ValueNode[k + 1];
            ValueNode[] dp = new ValueNode[k + 1];
            ValueNode[] t  = new ValueNode[k + 1];

            for (int i = 0; i < k + 1; i++) {

                ap[i] = new TestRegisterNode("a[" + i + "]", Datatype.AddressValue);
                bp[i] = new TestRegisterNode("b[" + i + "]", Datatype.AddressValue);
                s[i]  = new TestRegisterNode("s[" + i + "]", Datatype.FloatValue);

                g.AddNode(ap[i]);
                g.AddNode(bp[i]);
                g.AddNode(s[i]);

                cp[i] = new TestRegisterNode("c[" + i + "]", Datatype.AddressValue);
                dp[i] = new TestRegisterNode("d[" + i + "]", Datatype.AddressValue);
                t[i]  = new TestRegisterNode("t[" + i + "]", Datatype.FloatValue);

                g.AddNode(cp[i]);
                g.AddNode(dp[i]);
                g.AddNode(t[i]);
            }

            for (int i = 0; i < k; i++) {

                CreateSingleLoop(
                    g, ap[i], bp[i], s[i], ap[i + 1], bp[i + 1], s[i + 1]);

                CreateSingleLoop(
                    g, cp[i], dp[i], t[i], cp[i + 1], dp[i + 1], t[i + 1]);
            }

            g.InitInputValues();
            g.InitOutputValues();

            g.CyclicDependencies[s[0]] = s[k];
            g.CyclicDependencies[s[k]] = s[0];

            g.CyclicDependencies[ap[0]] = ap[k];
            g.CyclicDependencies[ap[k]] = ap[0];

            g.CyclicDependencies[bp[0]] = bp[k];
            g.CyclicDependencies[bp[k]] = bp[0];

            g.CyclicDependencies[t[0]] = t[k];
            g.CyclicDependencies[t[k]] = t[0];

            g.CyclicDependencies[cp[0]] = cp[k];
            g.CyclicDependencies[cp[k]] = cp[0];

            g.CyclicDependencies[dp[0]] = dp[k];
            g.CyclicDependencies[dp[k]] = dp[0];

            return g;
        }
Esempio n. 14
0
        public ProgramGraph CreateUnrolledProgramGraph(int k)
        {
            ProgramGraph g = new ProgramGraph();

            ValueNode[] px = new ValueNode[k];
            ValueNode[] x  = new ValueNode[k];

            ValueNode[] py = new ValueNode[k];
            ValueNode[] my = new ValueNode[k];
            ValueNode[] y  = new ValueNode[k];

            OperationNode[] lx = new OperationNode[k];
            OperationNode[] sy = new OperationNode[k];

            for (int i = 0; i < k; i++) {

                px[i] = new FloatMemoryNode("x[" + i + "]");
                lx[i] = new LoadOperationNode();
                x[i]  = new FloatRegisterNode();

                g.AddNode(px[i]);
                g.AddNode(lx[i]);
                g.AddNode(x[i]);

                g.AddEdge(px[i], lx[i]);
                g.AddEdge(lx[i], x[i]);

                y[i]  = new FloatRegisterNode();
                py[i] = new FloatMemoryNode("y[" + i + "]");
                sy[i] = new StoreOperationNode();
                my[i] = new FloatMemoryNode(null);

                g.AddNode(y[i]);
                g.AddNode(py[i]);
                g.AddNode(sy[i]);
                g.AddNode(my[i]);

                g.AddEdge(y[i], sy[i]);
                g.AddEdge(py[i], sy[i]);
                g.AddEdge(sy[i], my[i]);
            }

            ValueNode[] x0 = new ValueNode[k + 1];
            ValueNode[] x1 = new ValueNode[k + 1];

            for (int i = 0; i < k + 1; i++) {

                x0[i] = new FloatRegisterNode();
                x1[i] = new FloatRegisterNode();

                g.AddNode(x0[i]);
                g.AddNode(x1[i]);
            }

            ValueNode px00 = new FloatMemoryNode("x0[0]");
            ValueNode px10 = new FloatMemoryNode("x1[0]");

            OperationNode lx00 = new LoadOperationNode();
            OperationNode lx10 = new LoadOperationNode();

            g.AddNode(px00);
            g.AddNode(px10);
            g.AddNode(lx00);
            g.AddNode(lx10);

            g.AddEdge(px00, lx00);
            g.AddEdge(lx00, x0[0]);
            g.AddEdge(px10, lx10);
            g.AddEdge(lx10, x1[0]);

            ValueNode px0k = new FloatMemoryNode("x0[" + k + "]");
            ValueNode px1k = new FloatMemoryNode("x1[" + k + "]");

            ValueNode mx0k = new FloatMemoryNode(null);
            ValueNode mx1k = new FloatMemoryNode(null);

            OperationNode sx0k = new StoreOperationNode();
            OperationNode sx1k = new StoreOperationNode();

            g.AddNode(px0k);
            g.AddNode(px1k);
            g.AddNode(mx0k);
            g.AddNode(mx1k);
            g.AddNode(sx0k);
            g.AddNode(sx1k);

            g.AddEdge(x0[k], sx0k);
            g.AddEdge(px0k, sx0k);
            g.AddEdge(sx0k, mx0k);
            g.AddEdge(x1[k], sx1k);
            g.AddEdge(px1k, sx1k);
            g.AddEdge(sx1k, mx1k);

            ValueNode pc0 = new FloatMemoryNode("c0");
            ValueNode pc1 = new FloatMemoryNode("c1");
            ValueNode pc2 = new FloatMemoryNode("c2");
            ValueNode pc3 = new FloatMemoryNode("c3");
            ValueNode pc4 = new FloatMemoryNode("c4");

            OperationNode lc0 = new LoadOperationNode();
            OperationNode lc1 = new LoadOperationNode();
            OperationNode lc2 = new LoadOperationNode();
            OperationNode lc3 = new LoadOperationNode();
            OperationNode lc4 = new LoadOperationNode();

            ValueNode c0 = new FloatRegisterNode();
            ValueNode c1 = new FloatRegisterNode();
            ValueNode c2 = new FloatRegisterNode();
            ValueNode c3 = new FloatRegisterNode();
            ValueNode c4 = new FloatRegisterNode();

            g.AddNode(pc0); g.AddNode(pc1); g.AddNode(pc2);
            g.AddNode(pc3); g.AddNode(pc4);

            g.AddNode(lc0); g.AddNode(lc1); g.AddNode(lc2);
            g.AddNode(lc3); g.AddNode(lc4);

            g.AddNode(c0); g.AddNode(c1); g.AddNode(c2);
            g.AddNode(c3); g.AddNode(c4);

            g.AddEdge(pc0, lc0); g.AddEdge(lc0, c0);
            g.AddEdge(pc1, lc1); g.AddEdge(lc1, c1);
            g.AddEdge(pc2, lc2); g.AddEdge(lc2, c2);
            g.AddEdge(pc3, lc3); g.AddEdge(lc3, c3);
            g.AddEdge(pc4, lc4); g.AddEdge(lc4, c4);

            for (int i = 0; i < k; i++) {

                CreateSingleFilterLoop(
                    g, x[i], x0[i], x1[i], c0, c1, c2, c3, c4,
                    x0[i + 1], x1[i + 1], y[i]);
            }

            g.InitInputValues();
            g.InitOutputValues();

            return g;
        }
Esempio n. 15
0
 /// <summary>
 /// Initilaizes an instance of <see cref="GraphAnalyzer"/>.
 /// </summary>
 /// <param name="program">The boogie program.</param>
 public GraphAnalyzer(Microsoft.Boogie.Program program)
 {
     Graph = new ProgramGraph(program);
 }