Changeset 3937 in CLRX


Ignore:
Timestamp:
Mar 25, 2018, 8:52:32 PM (9 months ago)
Author:
matszpk
Message:

CLRadeonExtender: AsmRegAlloc?: Update (add unfinished passSecondRecurPass).

File:
1 edited

Legend:

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

    r3936 r3937  
    19231923    }
    19241924    std::cout << "--------- createRoutineData end ------------\n";
     1925}
     1926
     1927
     1928static void passSecondRecurPass(const std::vector<CodeBlock>& codeBlocks,
     1929            const ResSecondPointsToCache& cblocksToCache,
     1930            const std::unordered_set<size_t>& loopBlocks,
     1931            const std::unordered_map<size_t, RoutineData>& routineMap,
     1932            RetSSAIdMap& retSSAIdMap, SSAReplacesMap& ssaReplacesMap,
     1933            size_t recurBlock)
     1934{
     1935    std::unordered_map<AsmSingleVReg, size_t> curSSAIdMap;
     1936    SimpleCache<size_t, RoutineData> subroutinesCache(codeBlocks.size()<<3);
     1937   
     1938    // routineMapSP - routine Map for second of the recursion
     1939    std::unordered_map<size_t, RoutineData> routineMapSP;
     1940    std::vector<bool> isRoutineGen(codeBlocks.size(), false);
     1941    std::deque<CallStackEntry> callStack;
     1942    std::deque<FlowStackEntry> flowStack;
     1943    std::vector<bool> visited(codeBlocks.size(), false);
     1944    flowStack.push_back({ recurBlock, 0 });
     1945   
     1946    while (!flowStack.empty())
     1947    {
     1948        FlowStackEntry& entry = flowStack.back();
     1949        const CodeBlock& cblock = codeBlocks[entry.blockIndex];
     1950       
     1951        if (entry.nextIndex == 0)
     1952        {
     1953            // process current block
     1954            if (!visited[entry.blockIndex])
     1955            {
     1956                std::cout << "proc: " << entry.blockIndex << std::endl;
     1957                visited[entry.blockIndex] = true;
     1958               
     1959                for (const auto& ssaEntry: cblock.ssaInfoMap)
     1960                    if (ssaEntry.first.regVar != nullptr)
     1961                    {
     1962                        // put data to routine data
     1963                        //updateRoutineData(rdata, ssaEntry, curSSAIdMap[ssaEntry.first]-1);
     1964                       
     1965                        if (ssaEntry.second.ssaIdChange!=0)
     1966                            curSSAIdMap[ssaEntry.first] = ssaEntry.second.ssaIdLast+1;
     1967                    }
     1968            }
     1969            else
     1970            {
     1971                flowStack.pop_back();
     1972                continue;
     1973            }
     1974        }
     1975       
     1976        if (!callStack.empty() &&
     1977            entry.blockIndex == callStack.back().callBlock &&
     1978            entry.nextIndex-1 == callStack.back().callNextIndex)
     1979        {
     1980            std::cout << " ret: " << entry.blockIndex << std::endl;
     1981            const size_t routineBlock = callStack.back().routineBlock;
     1982            RoutineData& prevRdata = routineMapSP.find(routineBlock)->second;
     1983            if (!isRoutineGen[routineBlock])
     1984            {
     1985                createRoutineData(codeBlocks, curSSAIdMap, loopBlocks, cblocksToCache,
     1986                        subroutinesCache, routineMap, &routineMapSP, prevRdata,
     1987                        routineBlock);
     1988                //prevRdata.compare(myRoutineData);
     1989                isRoutineGen[routineBlock] = true;
     1990            }
     1991           
     1992            callStack.pop_back(); // just return from call
     1993            //callBlocks.erase(routineBlock);
     1994        }
     1995       
     1996        if (entry.nextIndex < cblock.nexts.size())
     1997        {
     1998            bool isCall = false;
     1999            const size_t nextBlock = cblock.nexts[entry.nextIndex].block;
     2000            if (cblock.nexts[entry.nextIndex].isCall)
     2001            {
     2002                std::cout << " call: " << entry.blockIndex << std::endl;
     2003                /*if (!callBlocks.insert(nextBlock).second)
     2004                {
     2005                    // if already called (then it is recursion)
     2006                    recurseBlocks.insert(nextBlock);
     2007                    std::cout << "   -- recursion: " << nextBlock << std::endl;
     2008                }*/
     2009               
     2010                callStack.push_back({ entry.blockIndex, entry.nextIndex, nextBlock });
     2011                routineMapSP.insert({ nextBlock, { } });
     2012                isCall = true;
     2013            }
     2014            entry.nextIndex++;
     2015        }
     2016        else if (((entry.nextIndex==0 && cblock.nexts.empty()) ||
     2017                // if have any call then go to next block
     2018                (cblock.haveCalls && entry.nextIndex==cblock.nexts.size())) &&
     2019                 !cblock.haveReturn && !cblock.haveEnd)
     2020        {
     2021            if (entry.nextIndex!=0) // if back from calls (just return from calls)
     2022            {
     2023                reduceSSAIdsForCalls(entry, codeBlocks, retSSAIdMap, routineMapSP,
     2024                                     ssaReplacesMap);
     2025                //
     2026                for (const NextBlock& next: cblock.nexts)
     2027                    if (next.isCall)
     2028                    {
     2029                        //std::cout << "joincall:"<< next.block << std::endl;
     2030                        auto it = routineMap.find(next.block); // must find
     2031                        initializePrevRetSSAIds(cblock, curSSAIdMap, retSSAIdMap,
     2032                                    it->second, entry);
     2033                        joinRetSSAIdMap(retSSAIdMap, it->second.lastSSAIdMap, next.block);
     2034                    }
     2035            }
     2036            /*flowStack.push_back({ entry.blockIndex+1, 0, false });
     2037            if (flowStackBlocks[entry.blockIndex+1])
     2038            {
     2039                loopBlocks.insert(entry.blockIndex+1);
     2040                 // keep to inserted in popping
     2041                flowStackBlocks[entry.blockIndex+1] = false;
     2042            }
     2043            else
     2044                flowStackBlocks[entry.blockIndex+1] = true;*/
     2045            entry.nextIndex++;
     2046        }
     2047        else
     2048        {
     2049            RoutineData* rdata = nullptr;
     2050            if (!callStack.empty())
     2051                rdata = &(routineMapSP.find(callStack.back().routineBlock)->second);
     2052           
     2053            // revert retSSAIdMap
     2054            revertRetSSAIdMap(curSSAIdMap, retSSAIdMap, entry, rdata);
     2055            //
     2056           
     2057            for (const auto& ssaEntry: cblock.ssaInfoMap)
     2058            {
     2059                if (ssaEntry.first.regVar == nullptr)
     2060                    continue;
     2061               
     2062                size_t& curSSAId = curSSAIdMap[ssaEntry.first];
     2063                const size_t nextSSAId = curSSAId;
     2064                curSSAId = ssaEntry.second.ssaIdBefore+1;
     2065               
     2066                std::cout << "popcurnext: " << ssaEntry.first.regVar <<
     2067                            ":" << ssaEntry.first.index << ": " <<
     2068                            nextSSAId << ", " << curSSAId << std::endl;
     2069            }
     2070           
     2071            std::cout << "pop: " << entry.blockIndex << std::endl;
     2072            //flowStackBlocks[entry.blockIndex] = false;
     2073            flowStack.pop_back();
     2074            /*if (!flowStack.empty() && lastCommonCacheWayPoint.first != SIZE_MAX &&
     2075                    lastCommonCacheWayPoint.second >= flowStack.size())
     2076            {
     2077                lastCommonCacheWayPoint =
     2078                        { flowStack.back().blockIndex, flowStack.size()-1 };
     2079                std::cout << "POPlastCcwP: " << lastCommonCacheWayPoint.first << std::endl;
     2080            }*/
     2081        }
     2082    }
    19252083}
    19262084
     
    22152373                std::cout << "POPlastCcwP: " << lastCommonCacheWayPoint.first << std::endl;
    22162374            }
    2217            
    22182375        }
    22192376    }
Note: See TracChangeset for help on using the changeset viewer.