Changeset 3616 in CLRX


Ignore:
Timestamp:
Jan 13, 2018, 5:09:46 PM (11 months ago)
Author:
matszpk
Message:

CLRadeonExtender: AsmRegAlloc?: Update createSSAData code. Asm: some typos in doxygen.

Location:
CLRadeonExtender/trunk
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • CLRadeonExtender/trunk/CLRX/amdasm/Assembler.h

    r3598 r3616  
    7474        size_t regUsages2Pos;   ///< position in regUsage2
    7575        size_t regVarUsagesPos;    ///< position in regVarUsage
    76         uint16_t pushedArgs;    ///< pused argds number
     76        uint16_t pushedArgs;    ///< pushed argds number
    7777        bool useRegMode;        ///< true if in usereg mode
    7878    };
     
    8989    size_t regUsages2Pos;   ///< position in reg usage 2
    9090    size_t regVarUsagesPos; ///< position in regvar usage
    91     uint16_t pushedArgs;    ///< pushed args 
     91    uint16_t pushedArgs;    ///< pushed args
    9292    cxbyte argPos;      ///< argument position
    9393    cxbyte argFlags;    ///< ???
  • CLRadeonExtender/trunk/amdasm/AsmRegAlloc.cpp

    r3615 r3616  
    460460};
    461461
     462struct FlowStackEntry2
     463{
     464    size_t blockIndex;
     465    size_t nextIndex;
     466};
     467
     468
    462469struct CallStackEntry
    463470{
    464471    size_t callBlock; // index
    465472    size_t callNextIndex; // index of call next
     473    size_t routineBlock;    // routine block
    466474};
    467475
     
    477485
    478486static void resolveSSAConflicts(const std::deque<FlowStackEntry>& prevFlowStack,
    479         const std::stack<CallStackEntry>& prevCallStack,
     487        const std::deque<CallStackEntry>& prevCallStack,
    480488        const std::vector<bool>& prevVisited,
    481489        const std::unordered_map<size_t, RoutineData>& routineMap,
     
    507515    }
    508516   
    509     std::stack<CallStackEntry> callStack = prevCallStack;
     517    //std::stack<CallStackEntry> callStack = prevCallStack;
    510518    // traverse by graph from next block
    511     std::deque<FlowStackEntry> flowStack;
     519    std::deque<FlowStackEntry2> flowStack;
    512520    flowStack.push_back({ nextBlock, 0 });
    513521    std::vector<bool> visited(codeBlocks.size(), false);
     
    518526    while (!flowStack.empty())
    519527    {
    520         FlowStackEntry& entry = flowStack.back();
     528        FlowStackEntry2& entry = flowStack.back();
    521529        const CodeBlock& cblock = codeBlocks[entry.blockIndex];
    522530       
     
    564572        }
    565573       
    566         if (!callStack.empty() &&
     574        /*if (!callStack.empty() &&
    567575            entry.blockIndex == callStack.top().callBlock &&
    568576            entry.nextIndex-1 == callStack.top().callNextIndex)
    569577            callStack.pop(); // just return from call
    570        
     578        */
    571579        if (entry.nextIndex < cblock.nexts.size() &&
    572580            prevVisited[cblock.nexts[entry.nextIndex].block])
    573581        {
    574             if (cblock.nexts[entry.nextIndex].isCall)
    575                 callStack.push({ entry.blockIndex, entry.nextIndex });
     582            /*if (cblock.nexts[entry.nextIndex].isCall)
     583                callStack.push({ entry.blockIndex, entry.nextIndex,
     584                            cblock.nexts[entry.nextIndex].block });*/
    576585            flowStack.push_back({ cblock.nexts[entry.nextIndex].block, 0 });
    577586            entry.nextIndex++;
     
    602611}
    603612
    604 static void joinRoutineData(LastSSAIdMap& dest, const LastSSAIdMap& src,
    605                 const std::unordered_map<AsmSingleVReg, SSAInfo>& prevSSAInfoMap)
    606 {
    607     for (const auto& entry: src)
    608     {
    609         if (entry.first.regVar==nullptr)
    610             continue;
    611         auto res = dest.insert(entry); // find
     613static void joinRoutineData(RoutineData& dest, const RoutineData& src)
     614{
     615    // insert readBeforeWrite only if doesnt exists in destination
     616    dest.rbwSSAIdMap.insert(src.rbwSSAIdMap.begin(), src.rbwSSAIdMap.end());
     617   
     618    for (const auto& sentry: src.lastSSAIdMap)
     619    {
     620        auto res = dest.lastSSAIdMap.insert(sentry);
    612621        if (res.second)
    613             continue; // added new
    614         auto ssaInfoIt = prevSSAInfoMap.find(entry.first);
    615         std::vector<size_t>& destEntry = res.first->second;
    616         if (ssaInfoIt == prevSSAInfoMap.end() || ssaInfoIt->second.ssaIdChange!=0)
    617         {
    618             if (ssaInfoIt != prevSSAInfoMap.end())
    619             {
    620                 auto it = std::find(destEntry.begin(), destEntry.end(),
    621                                     ssaInfoIt->second.ssaIdLast);
    622                 if (it != destEntry.end())
    623                     destEntry.erase(it); // remove old way
    624             }
    625             // add new ways
    626             for (size_t ssaId: entry.second)
    627             {
    628                 auto it = std::find(destEntry.begin(), destEntry.end(), ssaId);
    629                 if (it == destEntry.end())
    630                     destEntry.push_back(ssaId);
    631             }
    632         }
     622            continue; // inserted, go to next
     623        std::vector<size_t>& destSSAIds = res.first->second;
     624        destSSAIds.insert(destSSAIds.end(), sentry.second.begin(),
     625                sentry.second.end());
    633626    }
    634627}
     
    733726    }
    734727   
    735     std::stack<CallStackEntry> callStack;
     728    std::deque<CallStackEntry> callStack;
    736729    std::deque<FlowStackEntry> flowStack;
    737730    // total SSA count
     
    743736    // routine map - routine datas map, value - last SSA ids map
    744737    std::unordered_map<size_t, RoutineData> routineMap;
    745     // initialize routineMap
    746     /*for (const CodeBlock& cblock: codeBlocks)
    747         for (const NextBlock& next: cblock.nexts)
    748             // all forks and calls
    749             routineMap[next.block].processed = false;*/
    750    
    751     LastSSAIdMap lastMultiSSAIdMap; // current SSA id from visited calls
    752     std::unordered_set<size_t> selectedRoutines;
     738   
    753739    std::vector<bool> visited(codeBlocks.size(), false);
    754740    flowStack.push_back({ 0, 0 });
     
    769755                for (auto& ssaEntry: cblock.ssaInfoMap)
    770756                {
     757                    SSAInfo& sinfo = ssaEntry.second;
    771758                    if (ssaEntry.first.regVar==nullptr)
    772759                    {
    773                         ssaEntry.second.ssaIdChange = 0; // zeroing SSA changes
     760                        sinfo.ssaIdChange = 0; // zeroing SSA changes
    774761                        continue; // no change for registers
    775762                    }
    776763                   
    777764                    size_t& ssaId = curSSAIdMap[ssaEntry.first];
     765                    auto ssaIdsIt = retSSAIdMap.find(ssaEntry.first);
     766                    if (ssaIdsIt != retSSAIdMap.end() && sinfo.readBeforeWrite)
    778767                    {
    779                         auto& ssaIds = retSSAIdMap[ssaEntry.first];
    780                         if (ssaIds.size() >= 2 && ssaEntry.second.readBeforeWrite)
     768                        auto& ssaIds = ssaIdsIt->second;
     769                        // remove ssaIds from constructed routine datas (before reduction)
     770                        // SSAId can reduced in nested call, thus this loop
     771                        for (auto cit = callStack.rbegin(); cit != callStack.rend(); ++cit)
     772                        {
     773                            RoutineData& rdata =
     774                                    routineMap.find(cit->routineBlock)->second;
     775                            auto rsit = rdata.lastSSAIdMap.find(ssaEntry.first);
     776                            if (rsit == rdata.lastSSAIdMap.end())
     777                                continue;
     778                            // remove all current last SSAIds from routine data
     779                            for (size_t v: ssaIds)
     780                            {
     781                                auto sit = std::find(rsit->second.begin(),
     782                                        rsit->second.end(), v);
     783                                if (sit != rsit->second.end())
     784                                    rsit->second.erase(sit);
     785                            }
     786                            // remove entry if empty
     787                            if (rsit->second.empty())
     788                                rdata.lastSSAIdMap.erase(rsit->first);
     789                            break;
     790                        }
     791                       
     792                        if (ssaIds.size() >= 2)
    781793                        {
    782794                            // reduce to minimal ssaId from all calls
     
    791803                            ssaId = minSSAId+1; // plus one
    792804                            // finally remove from container (because obsolete)
    793                             retSSAIdMap.erase(ssaEntry.first);
     805                            retSSAIdMap.erase(ssaIdsIt);
     806                        }
     807                        else if (ssaIds.size() == 1)
     808                        {
     809                            ssaId = ssaIds.front()+1; // plus one
     810                            retSSAIdMap.erase(ssaIdsIt);
    794811                        }
    795812                    }
     
    806823                        entry.prevSSAIds.insert({ ssaEntry.first, ssaId });
    807824                   
    808                     ssaEntry.second.ssaId = totalSSACount;
    809                     ssaEntry.second.ssaIdFirst = ssaEntry.second.ssaIdChange!=0 ?
    810                         totalSSACount : SIZE_MAX;
    811                     ssaEntry.second.ssaIdBefore = ssaId-1;
     825                    sinfo.ssaId = totalSSACount;
     826                    sinfo.ssaIdFirst = sinfo.ssaIdChange!=0 ? totalSSACount : SIZE_MAX;
     827                    sinfo.ssaIdBefore = ssaId-1;
    812828                   
    813                     totalSSACount += ssaEntry.second.ssaIdChange;
    814                     ssaEntry.second.ssaIdLast = ssaEntry.second.ssaIdChange!=0 ?
    815                             totalSSACount-1 : SIZE_MAX;
     829                    totalSSACount += sinfo.ssaIdChange;
     830                    sinfo.ssaIdLast = sinfo.ssaIdChange!=0 ? totalSSACount-1 : SIZE_MAX;
    816831                    //totalSSACount = std::max(totalSSACount, ssaId);
    817832                    ssaId = totalSSACount;
     833                   
     834                    if (!callStack.empty())
     835                    {
     836                        // put data to routine data
     837                        RoutineData& rdata =
     838                                routineMap.find(callStack.back().routineBlock)->second;
     839                        // put first SSAId before write
     840                        if (sinfo.readBeforeWrite)
     841                            rdata.rbwSSAIdMap.insert({ ssaEntry.first,
     842                                    sinfo.ssaIdBefore });
     843                       
     844                        if (sinfo.ssaIdChange != 0)
     845                        {
     846                            // put last SSAId
     847                            auto res = rdata.lastSSAIdMap.insert({ ssaEntry.first,
     848                                    { sinfo.ssaIdLast } });
     849                            if (!res.second)
     850                            {
     851                                // if not inserted
     852                                std::vector<size_t>& ssaIds = res.first->second;
     853                                auto ssaIdIt = ssaIds.end();
     854                                if (sinfo.readBeforeWrite)
     855                                    ssaIdIt = std::find(ssaIds.begin(), ssaIds.end(),
     856                                            sinfo.ssaIdBefore);
     857                                if (ssaIdIt == ssaIds.end())
     858                                    ssaIds.push_back(sinfo.ssaIdLast);
     859                                else
     860                                    *ssaIdIt = sinfo.ssaIdLast;
     861                            }
     862                        }
     863                    }
    818864                }
    819                 // check if routineMap
    820                 auto rit = routineMap.find(entry.blockIndex);
    821                 if (rit != routineMap.end() && !rit->second.processed)
    822                     selectedRoutines.insert(entry.blockIndex);
    823865            }
    824866            else
    825867            {
    826868                // join routine data
    827                 auto rit = routineMap.find(entry.blockIndex);
     869                /*auto rit = routineMap.find(entry.blockIndex);
    828870                if (rit != routineMap.end() && rit->second.processed)
    829871                {
     
    841883                else if (rit != routineMap.end())
    842884                    // if not already processed, just mark it
    843                     rit->second.processed = true;
     885                    rit->second.processed = true;*/
    844886                   
    845887                resolveSSAConflicts(flowStack, callStack, visited, routineMap, codeBlocks,
     
    852894       
    853895        if (!callStack.empty() &&
    854             entry.blockIndex == callStack.top().callBlock &&
    855             entry.nextIndex-1 == callStack.top().callNextIndex)
     896            entry.blockIndex == callStack.back().callBlock &&
     897            entry.nextIndex-1 == callStack.back().callNextIndex)
    856898        {
    857899            //std::cout << " ret: " << entry.blockIndex << std::endl;
    858             callStack.pop(); // just return from call
     900            const RoutineData& prevRdata =
     901                    routineMap.find(callStack.back().routineBlock)->second;
     902            callStack.pop_back(); // just return from call
     903            if (callStack.empty())
     904            {   // put to main
     905            }
     906            else
     907                // put to parent routine
     908                joinRoutineData(routineMap.find(callStack.back().routineBlock)->second,
     909                                    prevRdata);
    859910        }
    860911       
     
    864915            {
    865916                //std::cout << " call: " << entry.blockIndex << std::endl;
    866                 callStack.push({ entry.blockIndex, entry.nextIndex });
     917                callStack.push_back({ entry.blockIndex, entry.nextIndex,
     918                            cblock.nexts[entry.nextIndex].block });
    867919                routineMap.insert({ cblock.nexts[entry.nextIndex].block, { false } });
    868920            }
     
    879931            {
    880932                // expand lastMultiSSAIdMap from all calls
    881                 /*for (const NextBlock& next: cblock.nexts)
     933                for (const NextBlock& next: cblock.nexts)
    882934                    if (next.isCall)
    883935                    {
    884936                        auto it = routineMap.find(next.block); // must find
    885                         joinLastSSAIdMap(lastMultiSSAIdMap, it->second.lastSSAIdMap);
    886                     }*/
     937                        joinLastSSAIdMap(retSSAIdMap, it->second.lastSSAIdMap);
     938                    }
    887939            }
    888940            flowStack.push_back({ entry.blockIndex+1, 0 });
     
    905957                lastMultiSSAIdMap.insert(entry.replacedMultiSSAIds.begin(),
    906958                                entry.replacedMultiSSAIds.end());*/
    907             // erase at pop from selectedRoutines
    908             selectedRoutines.erase(entry.blockIndex);
    909959           
    910960            for (const auto& ssaEntry: cblock.ssaInfoMap)
Note: See TracChangeset for help on using the changeset viewer.