Changeset 4091 in CLRX


Ignore:
Timestamp:
May 6, 2018, 5:44:29 PM (6 months ago)
Author:
matszpk
Message:

CLRadeonExtender: AsmRegAlloc?: Tentative version of the createRoutineDataLv (for createLivenesses).

Location:
CLRadeonExtender/trunk/amdasm
Files:
2 edited

Legend:

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

    r4090 r4091  
    12341234}
    12351235
     1236
     1237static void createRoutineDataLv(const std::vector<CodeBlock>& codeBlocks,
     1238        const RoutineLvMap& routineMap, RoutineDataLv& rdata,
     1239        size_t routineBlock, const VarIndexMap* vregIndexMaps,
     1240        std::vector<Liveness>* livenesses, size_t regTypesNum, const cxuint* regRanges)
     1241{
     1242    std::deque<FlowStackEntry4> flowStack;
     1243    std::vector<bool> visited(codeBlocks.size(), false);
     1244   
     1245    // already read in current path
     1246    // key - vreg, value - source block where vreg of conflict found
     1247    SVRegMap alreadyReadMap;
     1248   
     1249    flowStack.push_back({ routineBlock, 0 });
     1250    SVRegMap curSVRegMap; // key - svreg, value - block index
     1251   
     1252    while (!flowStack.empty())
     1253    {
     1254        FlowStackEntry4& entry = flowStack.back();
     1255        const CodeBlock& cblock = codeBlocks[entry.blockIndex];
     1256       
     1257        if (entry.nextIndex == 0)
     1258        {
     1259            // process current block
     1260            if (!visited[entry.blockIndex])
     1261            {
     1262                visited[entry.blockIndex] = true;
     1263               
     1264                for (const auto& sentry: cblock.ssaInfoMap)
     1265                {
     1266                    if (sentry.second.readBeforeWrite)
     1267                        if (alreadyReadMap.insert(
     1268                                    { sentry.first, entry.blockIndex }).second)
     1269                            rdata.readBeforeWrites.insert(sentry.first);
     1270                   
     1271                    auto res = curSVRegMap.insert({ sentry.first, entry.blockIndex });
     1272                    if (!res.second)
     1273                    {   // not added because is present in map
     1274                        entry.prevCurSVRegMap.insert(*res.first);
     1275                        res.first->second = entry.blockIndex;
     1276                    }
     1277                    else
     1278                        entry.prevCurSVRegMap.insert({ sentry.first, SIZE_MAX });
     1279                   
     1280                    // all SSAs
     1281                    const SSAInfo& sinfo = sentry.second;
     1282                    const AsmSingleVReg& svreg = sentry.first;
     1283                    cxuint regType = getRegType(regTypesNum, regRanges, svreg);
     1284                    const VarIndexMap& vregIndexMap = vregIndexMaps[regType];
     1285                    const std::vector<size_t>& ssaIdIndices =
     1286                                vregIndexMap.find(svreg)->second;
     1287                   
     1288                    // add SSA indices to allSSAs
     1289                    if (sinfo.readBeforeWrite)
     1290                        rdata.allSSAs[regType].insert(ssaIdIndices[sinfo.ssaIdBefore]);
     1291                    if (sinfo.ssaIdChange != 0)
     1292                    {
     1293                        rdata.allSSAs[regType].insert(ssaIdIndices[sinfo.ssaIdFirst]);
     1294                        for (size_t i = 1; i < sinfo.ssaIdChange; i++)
     1295                            rdata.allSSAs[regType].insert(ssaIdIndices[sinfo.ssaId+i]);
     1296                        rdata.allSSAs[regType].insert(ssaIdIndices[sinfo.ssaIdLast]);
     1297                    }
     1298                }
     1299            }
     1300            else
     1301            {
     1302                flowStack.pop_back();
     1303                continue;
     1304            }
     1305        }
     1306       
     1307        if (entry.nextIndex < cblock.nexts.size())
     1308        {
     1309            flowStack.push_back({ cblock.nexts[entry.nextIndex].block, 0 });
     1310            entry.nextIndex++;
     1311        }
     1312        else if (((entry.nextIndex==0 && cblock.nexts.empty()) ||
     1313                // if have any call then go to next block
     1314                (cblock.haveCalls && entry.nextIndex==cblock.nexts.size())) &&
     1315                 !cblock.haveReturn && !cblock.haveEnd)
     1316        {
     1317            flowStack.push_back({ entry.blockIndex+1, 0 });
     1318            entry.nextIndex++;
     1319        }
     1320        else
     1321        {
     1322            if (cblock.haveReturn)
     1323            {
     1324                // handle return
     1325                for (const auto& entry: curSVRegMap)
     1326                {
     1327                    auto res = rdata.lastAccessMap.insert({ entry.first,
     1328                                    { LastAccessBlockPos{  entry.second, false } } });
     1329                    if (!res.second)
     1330                        res.first->second.insertValue(
     1331                                    LastAccessBlockPos{ entry.second, false });
     1332                }
     1333            }
     1334            // revert curSVRegMap
     1335            for (const auto& sentry: entry.prevCurSVRegMap)
     1336                if (sentry.second != SIZE_MAX)
     1337                    curSVRegMap.find(sentry.first)->second = sentry.second;
     1338                else // no before that
     1339                    curSVRegMap.erase(sentry.first);
     1340           
     1341            for (const auto& sentry: cblock.ssaInfoMap)
     1342            {
     1343                auto it = alreadyReadMap.find(sentry.first);
     1344                if (it != alreadyReadMap.end() && it->second == entry.blockIndex)
     1345                    // remove old to resolve in leaved way to allow collecting next ssaId
     1346                    // before write (can be different due to earlier visit)
     1347                    alreadyReadMap.erase(it);
     1348            }
     1349            ARDOut << "  popjoin\n";
     1350            flowStack.pop_back();
     1351        }
     1352    }
     1353}
     1354
    12361355/* TODO: handling livenesses between routine call:
    12371356 *   for any routine call in call point:
     
    13041423    LastVRegMap lastVRegMap;
    13051424   
    1306     std::unordered_map<size_t, RoutineDataLv> routineMap;
    1307    
    13081425    // key - current res first key, value - previous first key and its flowStack pos
    13091426    PrevWaysIndexMap prevWaysIndexMap;
     
    13161433    size_t wrCount = 0;
    13171434   
     1435    RoutineLvMap routineMap;
    13181436    std::vector<Liveness> livenesses[MAX_REGTYPES_NUM];
    13191437   
     
    14721590        if (entry.nextIndex < cblock.nexts.size())
    14731591        {
    1474             bool isCall = false;
     1592            //bool isCall = false;
    14751593            size_t nextBlock = cblock.nexts[entry.nextIndex].block;
    14761594            if (cblock.nexts[entry.nextIndex].isCall)
    14771595            {
    14781596                callStack.push_back({ entry.blockIndex, entry.nextIndex, nextBlock });
    1479                 isCall = true;
     1597                //isCall = true;
    14801598            }
    14811599           
  • CLRadeonExtender/trunk/amdasm/AsmRegAlloc.h

    r4090 r4091  
    197197    size_t blockIndex;
    198198    bool inSubroutines; // true if last access in some called subroutine
    199 };
    200 
    201 typedef std::unordered_map<AsmSingleVReg, LastAccessBlockPos> LastAccessMap;
     199   
     200    bool operator==(const LastAccessBlockPos& v) const
     201    { return blockIndex==v.blockIndex; }
     202    bool operator!=(const LastAccessBlockPos& v) const
     203    { return blockIndex!=v.blockIndex; }
     204};
     205
     206typedef std::unordered_map<AsmSingleVReg, VectorSet<LastAccessBlockPos> > LastAccessMap;
    202207
    203208// Routine data for createLivenesses - holds svreg read before writes and
    204209// last access of the svregs
    205 class CLRX_INTERNAL RoutineDataLv
     210struct CLRX_INTERNAL RoutineDataLv
    206211{
    207212    std::unordered_set<AsmSingleVReg> readBeforeWrites;
    208213    // holds all vreg SSA's used in routine (used while creating call point)
    209214    // includes subroutines called in this routines
    210     std::unordered_set<size_t> allSSAs;
     215    std::unordered_set<size_t> allSSAs[MAX_REGTYPES_NUM];
    211216    // key - svreg, value - list of the last codeblocks where is svreg
    212217    LastAccessMap lastAccessMap;
    213218};
    214219
     220// used by createSSAData
    215221struct CLRX_INTERNAL FlowStackEntry
    216222{
     
    222228};
    223229
     230// used by resolveSSAConflicts
    224231struct CLRX_INTERNAL FlowStackEntry2
    225232{
     
    228235};
    229236
     237
     238// used by createLivenesses
    230239struct CLRX_INTERNAL FlowStackEntry3
    231240{
     
    235244};
    236245
     246struct CLRX_INTERNAL FlowStackEntry4
     247{
     248    size_t blockIndex;
     249    size_t nextIndex;
     250    bool isCall;
     251    SVRegMap prevCurSVRegMap;
     252};
     253
    237254struct CLRX_INTERNAL CallStackEntry
    238255{
     
    250267
    251268typedef std::unordered_map<BlockIndex, RoutineData> RoutineMap;
     269typedef std::unordered_map<BlockIndex, RoutineDataLv> RoutineLvMap;
    252270
    253271typedef std::unordered_map<size_t, std::pair<size_t, size_t> > PrevWaysIndexMap;
Note: See TracChangeset for help on using the changeset viewer.