Changeset 4177 in CLRX


Ignore:
Timestamp:
May 16, 2018, 8:10:57 PM (5 months ago)
Author:
matszpk
Message:

CLRadeonExtender: Fix few stupid bugs in ISAUsageHandler (wrong flushing between useRegMode and normal mode).
AsmRegAlloc?: Untested (failing) support for '.rvlin' in createLivenesses. Choose max align while substituting linearDeps.

Location:
CLRadeonExtender/trunk
Files:
4 edited

Legend:

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

    r4172 r4177  
    173173            instrStruct[instrStruct.size() - ((pushedArgs+7) >> 3) - 1] = pushedArgs;
    174174        }
     175        argFlags = 0;
     176        pushedArgs = 0;
    175177    }
    176178}
  • CLRadeonExtender/trunk/amdasm/AsmRegAllocLive.cpp

    r4176 r4177  
    818818}
    819819
    820 static void addUsageDeps(const cxbyte* ldeps, cxuint rvusNum,
    821             const AsmRegVarUsage* rvus, LinearDepMap* ldepsOut,
     820static bool addUsageDeps(const cxbyte* ldeps, const std::vector<AsmRegVarUsage>& rvus,
     821            const std::vector<AsmRegVarLinearDep>& instrLinDeps, LinearDepMap* ldepsOut,
    822822            std::unordered_map<AsmSingleVReg, SSAInfo>& ssaInfoMap,
    823823            const VarIndexMap* vregIndexMaps, const SVRegMap& ssaIdIdxMap,
     824            const std::vector<AsmSingleVReg>& readSVRegs,
    824825            const std::vector<AsmSingleVReg>& writtenSVRegs,
    825826            size_t regTypesNum, const cxuint* regRanges)
     
    860861            }
    861862        }
    862         ldepsOut[regType][vidxes[0]].align = align;
     863        ldepsOut[regType][vidxes[0]].align =
     864                std::max(ldepsOut[regType][vidxes[0]].align, align);
    863865        for (size_t k = 1; k < vidxes.size(); k++)
    864866        {
     
    868870    }
    869871    // add single arg linear dependencies
    870     for (cxuint i = 0; i < rvusNum; i++)
     872    for (cxuint i = 0; i < rvus.size(); i++)
    871873        if ((rvuAdded & (1U<<i)) == 0 && rvus[i].rstart+1<rvus[i].rend)
    872874        {
     
    874876            if (rvu.regVar == nullptr)
    875877                continue;
    876             std::vector<size_t> vidxes, vidxesPrev;
     878            std::vector<size_t> vidxes;
    877879            cxuint regType = UINT_MAX;
    878880            cxbyte align = rvus[i].align;
     
    895897                vidxes.push_back(outVIdx);
    896898            }
    897             ldepsOut[regType][vidxes[0]].align = align;
     899            ldepsOut[regType][vidxes[0]].align =
     900                std::max(ldepsOut[regType][vidxes[0]].align, align);
    898901            for (size_t j = 1; j < vidxes.size(); j++)
    899902            {
     
    902905            }
    903906        }
     907       
     908    // handle user defined linear dependencies
     909    for (const AsmRegVarLinearDep& ldep: instrLinDeps)
     910    {
     911        std::vector<size_t> vidxes, prevVidxes;
     912        cxuint regType = UINT_MAX;
     913        bool haveReadVidxes = false;
     914        for (uint16_t k = ldep.rstart; k < ldep.rend; k++)
     915        {
     916            AsmSingleVReg svreg = {ldep.regVar, k};
     917            auto ssaIdxIdIt = ssaIdIdxMap.find(svreg);
     918            auto ssaInfoIt = ssaInfoMap.find(svreg);
     919            if (ssaIdxIdIt == ssaIdIdxMap.end() || ssaInfoIt == ssaInfoMap.end())
     920                return false; // failed
     921           
     922            size_t ssaIdIdx = ssaIdxIdIt->second;
     923            const SSAInfo& ssaInfo = ssaInfoIt->second;
     924            size_t outVIdx;
     925           
     926            // if read or read-write (but not same write)
     927            if (std::find(readSVRegs.begin(), readSVRegs.end(),
     928                            svreg) != readSVRegs.end() &&
     929                std::find(writtenSVRegs.begin(), writtenSVRegs.end(),
     930                            svreg) != writtenSVRegs.end())
     931            {
     932                getVIdx(svreg, ssaIdIdx-1, ssaInfo, vregIndexMaps,
     933                            regTypesNum, regRanges, regType, outVIdx);
     934                // push variable index
     935                prevVidxes.push_back(outVIdx);
     936                haveReadVidxes = true;
     937            }
     938           
     939            getVIdx(svreg, ssaIdIdx, ssaInfo, vregIndexMaps,
     940                            regTypesNum, regRanges, regType, outVIdx);
     941            // push variable index
     942            vidxes.push_back(outVIdx);
     943            if(vidxes.size() != prevVidxes.size())
     944                // if prevVidxes not filled
     945                prevVidxes.push_back(outVIdx);
     946        }
     947        ldepsOut[regType][vidxes[0]].align =
     948            std::max(ldepsOut[regType][vidxes[0]].align, cxbyte(0));
     949        for (size_t j = 1; j < vidxes.size(); j++)
     950        {
     951            ldepsOut[regType][vidxes[j-1]].nextVidxes.insertValue(vidxes[j]);
     952            ldepsOut[regType][vidxes[j]].prevVidxes.insertValue(vidxes[j-1]);
     953        }
     954       
     955        // add from linear deps for read vidxes (prevVidxes)
     956        if (haveReadVidxes)
     957        {
     958            ldepsOut[regType][prevVidxes[0]].align =
     959                std::max(ldepsOut[regType][prevVidxes[0]].align, cxbyte(0));
     960            for (size_t j = 1; j < prevVidxes.size(); j++)
     961            {
     962                ldepsOut[regType][prevVidxes[j-1]].nextVidxes.insertValue(prevVidxes[j]);
     963                ldepsOut[regType][prevVidxes[j]].prevVidxes.insertValue(prevVidxes[j-1]);
     964            }
     965        }
     966    }
     967    return true;
    904968}
    905969
     
    13271391                            lv.insert(liveTime+1, liveTime+2);
    13281392                        }
     1393                       
     1394                        // collecting linear deps for instruction
     1395                        std::vector<AsmRegVarLinearDep> instrLinDeps;
     1396                        AsmRegVarLinearDep linDep = { SIZE_MAX, nullptr, 0, 0 };
     1397                        while (linDep.offset < oldOffset && linDepHandler.hasNext())
     1398                            linDep = linDepHandler.nextLinearDep();
     1399                        // if found
     1400                        while (linDep.offset == oldOffset)
     1401                        {
     1402                            // just put
     1403                            instrLinDeps.push_back(linDep);
     1404                            if (linDepHandler.hasNext())
     1405                                linDep = linDepHandler.nextLinearDep();
     1406                            else // no data
     1407                                break;
     1408                        }
    13291409                        // get linear deps and equal to
    13301410                        cxbyte lDeps[16];
     
    13321412                                    instrRVUs.data(), lDeps);
    13331413                       
    1334                         addUsageDeps(lDeps, instrRVUs.size(), instrRVUs.data(),
    1335                                 linearDepMaps, cblock.ssaInfoMap, vregIndexMaps,
    1336                                 ssaIdIdxMap, writtenSVRegs, regTypesNum, regRanges);
     1414                        if (!addUsageDeps(lDeps, instrRVUs, instrLinDeps, linearDepMaps,
     1415                                cblock.ssaInfoMap, vregIndexMaps, ssaIdIdxMap,
     1416                                readSVRegs, writtenSVRegs, regTypesNum, regRanges))
     1417                            assembler.printError(nullptr, "Linear deps failed");
    13371418                       
    13381419                        readSVRegs.clear();
     
    14181499                   
    14191500                    joinVRegRecur(flowStack, codeBlocks, routineMap,
    1420                                   vidxCallMap, vidxRoutineMap,
     1501                            vidxCallMap, vidxRoutineMap,
    14211502                            flowStackStart, entry.first, entry.second, vregIndexMaps,
    14221503                            livenesses, regTypesNum, regRanges, false);
  • CLRadeonExtender/trunk/tests/amdasm/AsmRegAlloc3.cpp

    r4174 r4177  
    26432643        true, ""
    26442644    },
    2645 #if 0
    2646     {   // 41 - some test
    2647         R"ffDXD(.regvar sa:s:8, va:v:8
    2648         s_mov_b32 sa[2], s4             # 0
    2649         s_mov_b32 sa[3], s4             # 4
    2650         s_mov_b32 sa[4], s5             # 8
    2651         s_mov_b32 sa[5], s6             # 12
    2652         s_mov_b32 sa[6], s7             # 16
    2653        
    2654         .cf_call routine
    2655         s_swappc_b64 s[0:1], s[2:3]     # 20
    2656        
    2657         s_add_u32 sa[2], sa[2], sa[0]   # 24
    2658         s_add_u32 sa[3], sa[3], sa[0]   # 28
    2659         s_add_u32 sa[4], sa[4], sa[1]   # 32
    2660         s_add_u32 sa[5], sa[5], sa[1]   # 36
    2661         s_add_u32 sa[6], sa[6], sa[1]   # 40
    2662         s_endpgm                        # 44
    2663        
    2664 routine:
    2665         s_xor_b32 sa[2], sa[2], sa[0]   # 48
    2666         s_xor_b32 sa[3], sa[3], sa[1]   # 52
    2667         s_cbranch_vccnz b0              # 56
    2668        
    2669         .cf_call routine2
    2670         s_swappc_b64 s[0:1], s[2:3]     # 60
    2671        
    2672         s_xor_b32 sa[3], sa[3], sa[1]   # 64
    2673         s_xor_b32 sa[6], sa[6], sa[1]   # 68
    2674         s_xor_b32 sa[5], sa[5], sa[0]   # 72
    2675         .cf_ret
    2676         s_setpc_b64 s[0:1]              # 76
    2677        
    2678 b0:     s_xor_b32 sa[3], sa[3], sa[0]   # 80
    2679         s_nop 7                         # 84
    2680         s_xor_b32 sa[6], sa[6], sa[0]   # 88
    2681         .cf_ret
    2682         s_setpc_b64 s[0:1]              # 92
    2683        
    2684 routine2:
    2685         s_xor_b32 sa[2], sa[2], sa[0]   # 96
    2686         s_xor_b32 sa[3], sa[3], sa[1]   # 100
    2687         s_cbranch_vccnz b1              # 104
    2688        
    2689         s_xor_b32 sa[3], sa[3], sa[1]   # 108
    2690         s_xor_b32 sa[6], sa[6], sa[1]   # 112
    2691         s_xor_b32 sa[4], sa[4], sa[0]   # 116
    2692         .cf_ret
    2693         s_setpc_b64 s[0:1]              # 120
    2694        
    2695 b1:     s_xor_b32 sa[3], sa[3], sa[0]   # 124
    2696         s_xor_b32 sa[2], sa[2], sa[0]   # 128
    2697         s_xor_b32 sa[6], sa[6], sa[0]   # 132
    2698         .cf_ret
    2699         s_setpc_b64 s[0:1]              # 136
    2700 )ffDXD",
    2701         {   // liveness
    2702             {   // for SGPRs
    2703                 { { 21, 24 }, { 48, 60 }, { 61, 77 },
    2704                     { 80, 93 }, { 96, 140 } }, // 0: S0
    2705                 { { 21, 24 }, { 48, 60 }, { 61, 77 },
    2706                     { 80, 93 }, { 96, 140 } }, // 1: S1
    2707                 { { 0, 24 }, { 48, 61 } }, // 2: S2
    2708                 { { 0, 24 }, { 48, 61 } }, // 3: S3
    2709                 { { 0, 5 } }, // 4: S4
    2710                 { { 0, 9 } }, // 5: S5
    2711                 { { 0, 13 } }, // 6: S6
    2712                 { { 0, 17 } }, // 7: S7
    2713                 { { 0, 29 }, { 48, 140 } }, // 8: sa[0]'0
    2714                 { { 0, 41 }, { 48, 140 } }, // 9: sa[1]'0
    2715                 { { 1, 24 }, { 48, 49 } }, // 10: sa[2]'0
    2716                 { { 24, 25 }, { 49, 140 } }, // 11: sa[2]'1
    2717                 { { 24, 25 }, { 64, 80 }, { 85, 96 }, { 97, 140 } }, // 12: sa[2]'2
    2718                 { }, // 14: sa[3]'0
    2719                 { }, // 15: sa[3]'1
    2720                 { }, // 16: sa[3]'2
    2721                 { }, // 17: sa[3]'3
    2722                 { }, // 18: sa[3]'4
    2723                 { }, // 19: sa[3]'5
    2724                 { }, // 20: sa[4]'0
    2725                 { }, // 21: sa[4]'1
    2726                 { }, // 22: sa[5]'0
    2727                 { }, // 23: sa[5]'1
    2728                 { }, // 24: sa[6]'0
    2729                 { }, // 25: sa[6]'1
    2730                 { }, // 26: sa[6]'2
    2731                 { }  // 27: sa[6]'3
    2732             }
    2733         },
    2734         { },
    2735         { },
    2736         { },
    2737         true, ""
    2738     },
    2739 #endif
    27402645    {   // 41 - second recursion testcase
    27412646        R"ffDXD(.regvar sa:s:8, va:v:8
     
    29402845        { }, // vidxCallMap
    29412846        true, ""
     2847    },
     2848#if 0
     2849    {   // 43 - user define linear deps (by '.rvlin')
     2850        R"ffDXD(.regvar sa:s:8, va:v:8
     2851        .rvlin sa[2:7]
     2852        .usereg sa[2:7]:r
     2853        s_mov_b32 sa[2], s4               # 0
     2854        s_cbranch_scc0 b1                       # 8
     2855b0:     .rvlin sa[2:7]
     2856        .usereg sa[2:7]:r
     2857        s_mov_b32 s1, s1
     2858        s_endpgm
     2859b1:     .rvlin va[3:6]
     2860        .usereg va[3:6]:w
     2861        s_mov_b32 s1, s1
     2862        s_endpgm
     2863)ffDXD",
     2864        {
     2865        },
     2866        { },
     2867        { },
     2868        { },
     2869        true, ""
    29422870    }
     2871#endif
    29432872};
    29442873
  • CLRadeonExtender/trunk/tests/amdasm/GCNRegVarUsage.cpp

    r4032 r4177  
    17161716        },
    17171717        true, ""
     1718    },
     1719    {   /* 28: failing testcase from AsmRegAlloc3 */
     1720        R"ffDXD(.regvar sa:s:8, va:v:8
     1721        .rvlin sa[2:7]
     1722        .usereg sa[2:7]:r
     1723        s_mov_b32 sa[2], s4               # 0
     1724        s_cbranch_scc0 b1                       # 8
     1725b0:     .rvlin sa[2:7]
     1726        .usereg sa[2:7]:r
     1727        s_mov_b32 s1, s1
     1728        s_endpgm
     1729b1:     .rvlin va[3:6]
     1730        .usereg va[3:6]:w
     1731        s_mov_b32 s1, s1
     1732        s_endpgm
     1733)ffDXD",
     1734        {
     1735            { 0, "sa", 2, 8, ASMFIELD_NONE, ASMRVU_READ, 0 },
     1736            { 0, "sa", 2, 3, GCNFIELD_SDST, ASMRVU_WRITE, 1 },
     1737            { 0, nullptr, 4, 5, GCNFIELD_SSRC0, ASMRVU_READ, 0 },
     1738            { 8, "sa", 2, 8, ASMFIELD_NONE, ASMRVU_READ, 0 },
     1739            { 8, nullptr, 1, 2, GCNFIELD_SDST, ASMRVU_WRITE, 0 },
     1740            { 8, nullptr, 1, 2, GCNFIELD_SSRC0, ASMRVU_READ, 0 },
     1741            { 16, "va", 3, 7, ASMFIELD_NONE, ASMRVU_WRITE, 0 },
     1742            { 16, nullptr, 1, 2, GCNFIELD_SDST, ASMRVU_WRITE, 0 },
     1743            { 16, nullptr, 1, 2, GCNFIELD_SSRC0, ASMRVU_READ, 0 }
     1744        },
     1745        true, ""
    17181746    }
    17191747};
     
    17501778    assertValue<bool>("testGCNRegVarUsages", testCaseName+".good",
    17511779                      testCase.good, good);
     1780    assertString("testGCNRegVarUsages", testCaseName+".errorMessages",
     1781              testCase.errorMessages, errorStream.str());
     1782   
    17521783    if (assembler.getSections().size()<1)
    17531784    {
     
    17911822                    cxuint(expectedRvu.align), cxuint(resultRvu.align));
    17921823    }
    1793     assertString("testGCNRegVarUsages", testCaseName+".errorMessages",
    1794               testCase.errorMessages, errorStream.str());
    17951824    assertTrue("testGCNRegVarUsages", testCaseName+"length",
    17961825                   j == testCase.regVarUsages.size());
Note: See TracChangeset for help on using the changeset viewer.