Changeset 3975 in CLRX


Ignore:
Timestamp:
Apr 9, 2018, 1:09:15 PM (3 months ago)
Author:
matszpk
Message:

CLRadeonExtender: AsmRegAlloc?: Prepping to better joining calls to recursions (separating regvar ssaids).
Do not join subroutine lastSSAIds into routine curSSAIds if subroutine have no returns.

Location:
CLRadeonExtender/trunk
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • CLRadeonExtender/trunk/amdasm/AsmRegAlloc.cpp

    r3973 r3975  
    695695    size_t nextIndex;
    696696    bool isCall;
     697    bool haveReturn;
    697698    RetSSAIdMap prevRetSSAIdSets;
    698699};
     
    17261727    std::cout << "--------- createRoutineData ----------------\n";
    17271728    CBlockBitPool visited(codeBlocks.size(), false);
     1729    CBlockBitPool haveReturnBlocks(codeBlocks.size(), false);
    17281730   
    17291731    VectorSet<BlockIndex> activeLoops;
     
    17401742    flowStackBlocks[routineBlock] = true;
    17411743   
     1744   
    17421745    while (!flowStack.empty())
    17431746    {
     
    18851888                std::cout << "use cached subr " << entry.blockIndex << std::endl;
    18861889                std::cout << "procret2: " << entry.blockIndex << std::endl;
     1890                if (visited[entry.blockIndex] && !haveReturnBlocks[entry.blockIndex])
     1891                {
     1892                    // no joining. no returns
     1893                    std::cout << "procretend2" << std::endl;
     1894                    flowStackBlocks[entry.blockIndex] = !flowStackBlocks[entry.blockIndex];
     1895                    flowStack.pop_back();
     1896                    continue;
     1897                }
    18871898                joinLastSSAIdMap(rdata.lastSSAIdMap, rdata.curSSAIdMap, *cachedRdata);
    18881899                // get not given rdata curSSAIdMap ssaIds but present in cachedRdata
     
    20562067                std::cout << "procretend" << std::endl;
    20572068                rdata.notFirstReturn = true;
    2058             }
     2069                entry.haveReturn = true;
     2070                haveReturnBlocks[entry.blockIndex] = true;
     2071            }
     2072           
     2073            const bool prevHaveReturn = entry.haveReturn;
    20592074           
    20602075            // revert retSSAIdMap
     
    21042119            flowStackBlocks[entry.blockIndex] = false;
    21052120            std::cout << "pop: " << entry.blockIndex << std::endl;
     2121           
    21062122            flowStack.pop_back();
     2123            // set up haveReturn
     2124            if (!flowStack.empty())
     2125            {
     2126                flowStack.back().haveReturn |= prevHaveReturn;
     2127                haveReturnBlocks[flowStack.back().blockIndex] =
     2128                        flowStack.back().haveReturn;
     2129            }
    21072130        }
    21082131    }
     
    22082231    std::unordered_set<size_t> recurseBlocks;
    22092232   
     2233    /*
     2234     * find recursions
     2235     */
     2236    while (!flowStack.empty())
     2237    {
     2238        FlowStackEntry& entry = flowStack.back();
     2239        CodeBlock& cblock = codeBlocks[entry.blockIndex.index];
     2240       
     2241        if (entry.nextIndex == 0)
     2242        {
     2243            // process current block
     2244            if (!visited[entry.blockIndex])
     2245            {
     2246                visited[entry.blockIndex] = true;
     2247            }
     2248            else
     2249            {
     2250                flowStack.pop_back();
     2251                continue;
     2252            }
     2253        }
     2254       
     2255        if (!callStack.empty() &&
     2256            entry.blockIndex == callStack.back().callBlock &&
     2257            entry.nextIndex-1 == callStack.back().callNextIndex)
     2258        {
     2259            const BlockIndex routineBlock = callStack.back().routineBlock;
     2260            callStack.pop_back(); // just return from call
     2261            callBlocks.erase(routineBlock);
     2262            std::cout << "finding recur: ret: " << routineBlock << std::endl;
     2263        }
     2264       
     2265        if (entry.nextIndex < cblock.nexts.size())
     2266        {
     2267            bool isCall = false;
     2268            BlockIndex nextBlock = cblock.nexts[entry.nextIndex].block;
     2269           
     2270            if (cblock.nexts[entry.nextIndex].isCall)
     2271            {
     2272                if (!callBlocks.insert(nextBlock).second)
     2273                {
     2274                    // if already called (then it is recursion)
     2275                    std::cout << "finding recursions: " << nextBlock << std::endl;
     2276                    recurseBlocks.insert(nextBlock.index).second;
     2277                    entry.nextIndex++;
     2278                    continue;
     2279                }
     2280                callStack.push_back({ entry.blockIndex, entry.nextIndex, nextBlock });
     2281                std::cout << "finding recur: call: " << nextBlock << std::endl;
     2282                isCall = true;
     2283            }
     2284           
     2285            flowStack.push_back({ nextBlock, 0, isCall });
     2286            entry.nextIndex++;
     2287        }
     2288        else if (((entry.nextIndex==0 && cblock.nexts.empty()) ||
     2289                // if have any call then go to next block
     2290                (cblock.haveCalls && entry.nextIndex==cblock.nexts.size())) &&
     2291                 !cblock.haveReturn && !cblock.haveEnd)
     2292        {
     2293            flowStack.push_back({ entry.blockIndex+1, 0, false });
     2294            entry.nextIndex++;
     2295        }
     2296        else // back
     2297            flowStack.pop_back();
     2298    }
     2299   
     2300    recurseBlocks.clear();
     2301    callStack.clear();
     2302    callBlocks.clear();
     2303    flowStack.clear();
     2304    flowStack.push_back({ 0, 0 });
     2305    std::fill(visited.begin(), visited.end(), false);
     2306   
    22102307    std::unordered_map<size_t, std::unordered_map<AsmSingleVReg, size_t> >
    22112308            curSSAIdMapStateMap;
    22122309   
     2310    /*
     2311     * main loop to fill up ssaInfos
     2312     */
    22132313    while (!flowStack.empty())
    22142314    {
  • CLRadeonExtender/trunk/tests/amdasm/AsmRegAllocCase3.cpp

    r3974 r3975  
    17611761        true, ""
    17621762    },
     1763    {   // 12 - routine with program end, and jump to subroutine without end
     1764        // checking skipping joinning retSSAIds while joining subroutine
     1765        R"ffDXD(.regvar sa:s:8, va:v:8
     1766        s_mov_b32 sa[2], s4
     1767        s_mov_b32 sa[3], s4
     1768        s_mov_b32 sa[4], s4
     1769        s_mov_b32 sa[5], s5
     1770       
     1771        .cf_call routine
     1772        s_swappc_b64 s[0:1], s[2:3]
     1773       
     1774        s_add_u32 sa[2], sa[2], sa[0]
     1775        s_add_u32 sa[3], sa[3], sa[0]
     1776        s_add_u32 sa[4], sa[4], sa[0]
     1777        s_add_u32 sa[5], sa[5], sa[0]
     1778        s_endpgm
     1779       
     1780routine:
     1781        s_add_u32 sa[2], sa[2], sa[0]
     1782        .cf_cjump b0, b1, b2
     1783        s_setpc_b64 s[0:1]
     1784       
     1785        s_add_u32 sa[3], sa[3], sa[0]
     1786        .cf_ret
     1787        s_setpc_b64 s[0:1]
     1788       
     1789b0:     s_add_u32 sa[2], sa[2], sa[0]
     1790        s_add_u32 sa[3], sa[3], sa[0]
     1791        s_add_u32 sa[4], sa[4], sa[0]
     1792        s_endpgm
     1793       
     1794b1:     s_add_u32 sa[4], sa[4], sa[0]
     1795        s_branch b0
     1796       
     1797b2:     s_add_u32 sa[5], sa[5], sa[0]
     1798        s_branch b0
     1799)ffDXD",
     1800        {
     1801            {   // block 0 - start
     1802                0, 20,
     1803                { { 2, true } },
     1804                {
     1805                    { { "", 0 }, SSAInfo(0, 0, 0, 0, 0, false) },
     1806                    { { "", 1 }, SSAInfo(0, 0, 0, 0, 0, false) },
     1807                    { { "", 2 }, SSAInfo(0, 0, 0, 0, 0, true) },
     1808                    { { "", 3 }, SSAInfo(0, 0, 0, 0, 0, true) },
     1809                    { { "", 4 }, SSAInfo(0, 0, 0, 0, 0, true) },
     1810                    { { "", 5 }, SSAInfo(0, 0, 0, 0, 0, true) },
     1811                    { { "sa", 2 }, SSAInfo(0, 1, 1, 1, 1, false) },
     1812                    { { "sa", 3 }, SSAInfo(0, 1, 1, 1, 1, false) },
     1813                    { { "sa", 4 }, SSAInfo(0, 1, 1, 1, 1, false) },
     1814                    { { "sa", 5 }, SSAInfo(0, 1, 1, 1, 1, false) }
     1815                }, true, false, false },
     1816            {   // block 1 - end
     1817                20, 40,
     1818                { },
     1819                {
     1820                    { { "sa", 0 }, SSAInfo(0, SIZE_MAX, 1, SIZE_MAX, 0, true) },
     1821                    { { "sa", 2 }, SSAInfo(2, 4, 4, 4, 1, true) },
     1822                    { { "sa", 3 }, SSAInfo(2, 4, 4, 4, 1, true) },
     1823                    { { "sa", 4 }, SSAInfo(1, 4, 4, 4, 1, true) },
     1824                    { { "sa", 5 }, SSAInfo(1, 3, 3, 3, 1, true) }
     1825                }, false, false, true },
     1826            {   // block 2 - routine
     1827                40, 48,
     1828                { { 3, false }, { 4, false }, { 5, false }, { 6, false } },
     1829                {
     1830                    { { "", 0 }, SSAInfo(0, 0, 0, 0, 0, true) },
     1831                    { { "", 1 }, SSAInfo(0, 0, 0, 0, 0, true) },
     1832                    { { "sa", 0 }, SSAInfo(0, SIZE_MAX, 1, SIZE_MAX, 0, true) },
     1833                    { { "sa", 2 }, SSAInfo(1, 2, 2, 2, 1, true) }
     1834                }, false, false, false },
     1835            {   // block 3 - routine end 1
     1836                48, 56,
     1837                { },
     1838                {
     1839                    { { "", 0 }, SSAInfo(0, 0, 0, 0, 0, true) },
     1840                    { { "", 1 }, SSAInfo(0, 0, 0, 0, 0, true) },
     1841                    { { "sa", 0 }, SSAInfo(0, SIZE_MAX, 1, SIZE_MAX, 0, true) },
     1842                    { { "sa", 3 }, SSAInfo(1, 2, 2, 2, 1, true) }
     1843                }, false, true, true },
     1844            {   // block 4 - routine end 2
     1845                56, 72,
     1846                { },
     1847                {
     1848                    { { "sa", 0 }, SSAInfo(0, SIZE_MAX, 1, SIZE_MAX, 0, true) },
     1849                    { { "sa", 2 }, SSAInfo(2, 3, 3, 3, 1, true) },
     1850                    { { "sa", 3 }, SSAInfo(1, 3, 3, 3, 1, true) },
     1851                    { { "sa", 4 }, SSAInfo(1, 2, 2, 2, 1, true) }
     1852                }, false, false, true },
     1853            {   // block 5 - b1
     1854                72, 80,
     1855                { { 4, false } },
     1856                {
     1857                    { { "sa", 0 }, SSAInfo(0, SIZE_MAX, 1, SIZE_MAX, 0, true) },
     1858                    { { "sa", 4 }, SSAInfo(1, 3, 3, 3, 1, true) }
     1859                }, false, false, true },
     1860            {   // block 6 - b2
     1861                80, 88,
     1862                { { 4, false } },
     1863                {
     1864                    { { "sa", 0 }, SSAInfo(0, SIZE_MAX, 1, SIZE_MAX, 0, true) },
     1865                    { { "sa", 5 }, SSAInfo(1, 2, 2, 2, 1, true) }
     1866                }, false, false, true },
     1867        },
     1868        {   // SSA replaces
     1869            { { "sa", 4 }, { { 3, 1 } } }
     1870        },
     1871        true, ""
     1872    },
    17631873    { nullptr }
    17641874};
Note: See TracChangeset for help on using the changeset viewer.