Changeset 3618 in CLRX


Ignore:
Timestamp:
Jan 14, 2018, 10:11:59 PM (3 years ago)
Author:
matszpk
Message:

CLRadeonExtender: AsmRegAlloc?: Update createSSAData and resolveSSAConflicts code.

File:
1 edited

Legend:

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

    r3617 r3618  
    445445typedef std::unordered_map<AsmSingleVReg, std::vector<size_t> > LastSSAIdMap;
    446446
    447 // map of ReadBeforeWrite - value - SSAId, count of occurrences
    448 typedef std::unordered_map<AsmSingleVReg, std::pair<size_t, size_t> > RBWSSAIdMap;
    449 
    450447struct RoutineData
    451448{
    452449    bool processed;
    453     size_t cfReturns;   // number of returns in routine
    454450    // rbwSSAIdMap - read before write SSAId's map
    455     RBWSSAIdMap rbwSSAIdMap;
     451    std::unordered_map<AsmSingleVReg, size_t> rbwSSAIdMap;
    456452    LastSSAIdMap lastSSAIdMap;
    457453};
     
    461457    size_t blockIndex;
    462458    size_t nextIndex;
    463     bool fromCall;
    464459    std::unordered_map<AsmSingleVReg, size_t> prevSSAIds;
    465460};
     
    494489        const std::unordered_map<size_t, RoutineData>& routineMap,
    495490        const std::vector<CodeBlock>& codeBlocks,
    496         SSAReplacesMap& replacesMap)
     491        SSAReplacesMap& replacesMap,
     492        std::unordered_set<AsmSingleVReg>* joinedRegs = nullptr)
    497493{
    498494    size_t nextBlock = prevFlowStack.back().blockIndex;
     
    543539                for (auto& sentry: cblock.ssaInfoMap)
    544540                {
     541                    if (joinedRegs != nullptr)
     542                        joinedRegs->insert(sentry.first);
     543                   
    545544                    const SSAInfo& sinfo = sentry.second;
    546545                    auto res = toResolveMap.insert({ sentry.first, entry.blockIndex, });
     
    554553                       
    555554                        if (it != stackVarMap.end())
     555                        {
     556                           
     557                           
    556558                            // found, resolve by set ssaIdLast
    557559                            for (size_t ssaId: it->second)
     
    575577                                        ssaId << "," << sinfo.ssaIdBefore << std::endl;*/
    576578                            }
     579                        }
    577580                    }
    578581                }
     
    742745    // routine map - routine datas map, value - last SSA ids map
    743746    std::unordered_map<size_t, RoutineData> routineMap;
    744     // indicator for code block - number of ways that have return
    745     std::vector<size_t> waysHaveReturn(codeBlocks.size(), 0);
    746747   
    747748    std::vector<bool> visited(codeBlocks.size(), false);
     
    760761                //std::cout << "proc: " << entry.blockIndex << std::endl;
    761762                visited[entry.blockIndex] = true;
    762                
    763                 if (cblock.haveReturn)
    764                     waysHaveReturn[entry.blockIndex] = 1;
    765763               
    766764                for (auto& ssaEntry: cblock.ssaInfoMap)
     
    859857                        // put first SSAId before write
    860858                        if (sinfo.readBeforeWrite)
    861                         {
    862                             auto res = rdata.rbwSSAIdMap.insert({ ssaEntry.first,
    863                                 { sinfo.ssaIdBefore, 1 } });
    864                             if (!res.second && res.first->second.first == sinfo.ssaIdBefore)
    865                                 res.first->second.second++; // increase count
    866                         }
     859                            rdata.rbwSSAIdMap.insert({ ssaEntry.first, sinfo.ssaIdBefore });
    867860                       
    868861                        if (sinfo.ssaIdChange != 0)
     
    877870                                auto ssaIdIt = ssaIds.end();
    878871                                if (sinfo.readBeforeWrite)
    879                                 {
    880872                                    ssaIdIt = std::find(ssaIds.begin(), ssaIds.end(),
    881873                                            sinfo.ssaIdBefore);
    882                                     // found in readBeforeWrite decrease when replaced
    883                                     // by new SSAId
    884                                     auto rbwit = rdata.rbwSSAIdMap.find(ssaEntry.first);
    885                                     if (rbwit != rdata.rbwSSAIdMap.end() &&
    886                                         rbwit->second.first == sinfo.ssaIdBefore)
    887                                         rbwit->second.second--; // decrease used
    888                                 }
    889874                                if (ssaIdIt == ssaIds.end())
    890875                                    ssaIds.push_back(sinfo.ssaIdLast);
     
    916901                    // if not already processed, just mark it
    917902                    rit->second.processed = true;*/
    918                    
     903               
     904                std::unordered_set<AsmSingleVReg> joinedRegs;
    919905                resolveSSAConflicts(flowStack, callStack, visited, routineMap, codeBlocks,
    920                                     ssaReplacesMap);
     906                                    ssaReplacesMap, &joinedRegs);
     907                if (!callStack.empty())
     908                {
     909                    RoutineData& rdata =
     910                        (routineMap.find(callStack.back().routineBlock)->second);
     911                    for (const AsmSingleVReg& vreg: joinedRegs)
     912                    {
     913                        auto cssaIdIt = curSSAIdMap.find(vreg);
     914                        if (cssaIdIt == curSSAIdMap.end())
     915                            continue;
     916                        auto rlit = rdata.lastSSAIdMap.find(vreg);
     917                        if (rlit == rdata.lastSSAIdMap.end())
     918                            continue;
     919                        // remove old SSAId from list (if used in this way)
     920                        // TODO: compare first SSAId in this way and current last SSAId
     921                        auto rllit = std::find(rlit->second.begin(),
     922                                    rlit->second.end(), cssaIdIt->second-1);
     923                        if (rllit != rlit->second.end())
     924                            rlit->second.erase(rllit);
     925                    }
     926                }
    921927                // back, already visited
    922                 const size_t prevReturns = waysHaveReturn[entry.blockIndex];
    923                 const bool fromCall = entry.fromCall;
    924928                flowStack.pop_back();
    925                 if (!flowStack.empty() && !fromCall)
    926                     waysHaveReturn[flowStack.back().blockIndex] += prevReturns;
    927929                continue;
    928930            }
     
    953955                callStack.push_back({ entry.blockIndex, entry.nextIndex,
    954956                            cblock.nexts[entry.nextIndex].block });
    955                 routineMap.insert({ cblock.nexts[entry.nextIndex].block, { false, 0 } });
     957                routineMap.insert({ cblock.nexts[entry.nextIndex].block, { false } });
    956958            }
    957959           
    958             flowStack.push_back({ cblock.nexts[entry.nextIndex].block, 0,
    959                         cblock.nexts[entry.nextIndex].isCall });
     960            flowStack.push_back({ cblock.nexts[entry.nextIndex].block, 0 });
    960961            entry.nextIndex++;
    961962        }
     
    975976                    }
    976977            }
    977             flowStack.push_back({ entry.blockIndex+1, 0, false });
     978            flowStack.push_back({ entry.blockIndex+1, 0 });
    978979            entry.nextIndex++;
    979980        }
     
    995996                                entry.replacedMultiSSAIds.end());*/
    996997           
     998            RoutineData* rdata = nullptr;
     999            if (!callStack.empty())
     1000                rdata = &(routineMap.find(callStack.back().routineBlock)->second);
     1001           
    9971002            for (const auto& ssaEntry: cblock.ssaInfoMap)
    9981003            {
    9991004                auto it = entry.prevSSAIds.find(ssaEntry.first);
     1005                size_t& curSSAId = curSSAIdMap[ssaEntry.first];
     1006                const size_t nextSSAId = curSSAId;
    10001007                if (it == entry.prevSSAIds.end())
    1001                     curSSAIdMap[ssaEntry.first] -= ssaEntry.second.ssaIdChange;
     1008                    curSSAId -= ssaEntry.second.ssaIdChange;
    10021009                else // if found
    1003                     curSSAIdMap[ssaEntry.first] = it->second;
     1010                    curSSAId = it->second;
     1011                if (rdata!=nullptr)
     1012                {
     1013                    std::vector<size_t>& ssaIds = rdata->lastSSAIdMap
     1014                            .find(ssaEntry.first)->second;
     1015                    if (!cblock.nexts.empty() || (!cblock.haveEnd && !cblock.haveReturn))
     1016                    {   // if cblock with some children
     1017                        auto nit = std::find(ssaIds.begin(), ssaIds.end(), nextSSAId-1);
     1018                        if (nit != ssaIds.end())
     1019                            ssaIds.erase(nit);  // just remove
     1020                    }
     1021                    // push previous SSAId to lastSSAIdMap (later will be replaced)
     1022                    if (std::find(ssaIds.begin(), ssaIds.end(), curSSAId-1) == ssaIds.end())
     1023                        ssaIds.push_back(curSSAId-1);
     1024                }
    10041025            }
    10051026           
    1006             if (!callStack.empty() && codeBlocks[entry.blockIndex].haveReturn)
    1007                 // add return to routine cfReturns (number of return ways)
    1008                 routineMap[callStack.back().routineBlock].cfReturns++;
    1009            
    1010             const size_t prevReturns = waysHaveReturn[entry.blockIndex];
    1011             const bool fromCall = entry.fromCall;
    10121027            //std::cout << "pop" << std::endl;
    10131028            flowStack.pop_back();
    1014             if (!flowStack.empty() && !fromCall)
    1015                 waysHaveReturn[flowStack.back().blockIndex] += prevReturns;
    10161029        }
    10171030    }
Note: See TracChangeset for help on using the changeset viewer.