Changeset 2604 in CLRX


Ignore:
Timestamp:
Dec 1, 2016, 11:08:20 PM (3 years ago)
Author:
matszpk
Message:

CLRadeonExtender: AsmROCm: tentative version of code to setup kernel configuration.
Fixed setting alignments and wavefront size (power of 2). Add extra symbols to output.
GPUId: Add AMDGPUArchValues to GPUId.

Location:
CLRadeonExtender/trunk
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • CLRadeonExtender/trunk/CLRX/utils/GPUId.h

    r2386 r2604  
    135135              Flags flags);
    136136
     137struct AMDGPUArchValues
     138{
     139    uint32_t major;
     140    uint32_t minor;
     141    uint32_t stepping;
     142};
     143
    137144};
    138145
  • CLRadeonExtender/trunk/amdasm/AsmROCmFormat.cpp

    r2603 r2604  
    279279    {
    280280        config.reset(new AsmROCmKernelConfig{});
    281         ::memset(config.get(), 0, sizeof(AsmROCmKernelConfig));
    282         config->amdCodeVersionMajor = BINGEN_DEFAULT;
    283         config->amdCodeVersionMinor = BINGEN_DEFAULT;
     281        // set default values to kernel config
     282        ::memset(config.get(), 0xff, 128);
     283        ::memset(config->controlDirective, 0xff, 128);
     284        config->computePgmRsrc1 = config->computePgmRsrc2 = 0;
     285        config->enableSpgrRegisterFlags = 0;
     286        config->enableFeatureFlags = 0;
     287        config->reserved1[0] = config->reserved1[1] = config->reserved1[2] = 0;
     288        config->dimMask = 0;
     289        config->usedVGPRsNum = BINGEN_DEFAULT;
     290        config->usedSGPRsNum = BINGEN_DEFAULT;
     291        config->userDataNum = BINGEN8_DEFAULT;
     292        config->ieeeMode = false;
     293        config->floatMode = 0xc0;
     294        config->priority = 0;
     295        config->exceptions = 0;
     296        config->tgSize = false;
     297        config->debugMode = false;
     298        config->privilegedMode = false;
     299        config->dx10Clamp = false;
     300        config->localSize = BINGEN_DEFAULT;
     301        config->scratchBufferSize = BINGEN_DEFAULT;
    284302    }
    285303}
     
    446464                }
    447465                break;
     466            case ROCMCVAL_KERNARG_SEGMENT_ALIGN:
     467            case ROCMCVAL_GROUP_SEGMENT_ALIGN:
     468            case ROCMCVAL_PRIVATE_SEGMENT_ALIGN:
     469                if (1ULL<<(63-CLZ64(value)) != value)
     470                {
     471                    asmr.printError(valuePlace, "Alignment must be power of two");
     472                    good = false;
     473                }
     474                else if (value < 16)
     475                {
     476                    asmr.printError(valuePlace, "Alignment must be not smaller than 16");
     477                    good = false;
     478                }
     479                break;
     480            case ROCMCVAL_WAVEFRONT_SIZE:
     481                if (1ULL<<(63-CLZ64(value)) != value)
     482                {
     483                    asmr.printError(valuePlace, "Wavefront size must be power of two");
     484                    good = false;
     485                }
     486                break;
    448487            default:
    449488                break;
     
    540579            break;
    541580        case ROCMCVAL_KERNARG_SEGMENT_ALIGN:
    542             config.kernargSegmentAlignment = value;
     581            config.kernargSegmentAlignment = 63-CLZ64(value);
    543582            break;
    544583        case ROCMCVAL_GROUP_SEGMENT_ALIGN:
    545             config.groupSegmentAlignment = value;
     584            config.groupSegmentAlignment = 63-CLZ64(value);
    546585            break;
    547586        case ROCMCVAL_PRIVATE_SEGMENT_ALIGN:
    548             config.privateSegmentAlignment = value;
     587            config.privateSegmentAlignment = 63-CLZ64(value);
    549588            break;
    550589        case ROCMCVAL_WAVEFRONT_SIZE:
    551             config.wavefrontSize = value;
     590            config.wavefrontSize = 63-CLZ64(value);
    552591            break;
    553592        case ROCMCVAL_CALL_CONVENTION:
     
    10961135}
    10971136
     1137namespace CLRX
     1138{
     1139extern const AMDGPUArchValues rocmAmdGpuArchValuesTbl[];
     1140}
     1141
    10981142bool AsmROCmHandler::prepareBinary()
    10991143{
    11001144    bool good = true;
    11011145    size_t sectionsNum = sections.size();
    1102     size_t kernelsNum = kernelStates.size();
    11031146    output.deviceType = assembler.getDeviceType();
    11041147   
     
    11661209    // set up number of the allocated SGPRs and VGPRs for kernel
    11671210    cxuint maxSGPRsNum = getGPUMaxRegistersNum(arch, REGTYPE_SGPR, 0);
     1211   
     1212    AMDGPUArchValues amdGpuArchValues = rocmAmdGpuArchValuesTbl[
     1213                    cxuint(assembler.deviceType)];
     1214    if (output.archMinor!=UINT32_MAX)
     1215        amdGpuArchValues.minor = output.archMinor;
     1216    if (output.archStepping!=UINT32_MAX)
     1217        amdGpuArchValues.stepping = output.archStepping;
     1218   
     1219    const cxuint ldsShift = arch<GPUArchitecture::GCN1_1 ? 8 : 9;
     1220    const uint32_t ldsMask = (1U<<ldsShift)-1U;
    11681221    // prepare kernels configuration
    11691222    for (size_t i = 0; i < kernelStates.size(); i++)
     
    11751228        AsmROCmKernelConfig& config = *kernel.config.get();
    11761229        // setup config
    1177         //config.enableSpgrRegisterFlags = (config.enableSpgrRegisterFlags&~64) |
    1178         cxuint userSGPRsNum = config.userDataNum;
     1230        // fill default values
     1231        if (config.amdCodeVersionMajor == BINGEN_DEFAULT)
     1232            config.amdCodeVersionMajor = 1;
     1233        if (config.amdCodeVersionMinor == BINGEN_DEFAULT)
     1234            config.amdCodeVersionMinor = 0;
     1235        if (config.amdMachineKind == BINGEN_DEFAULT)
     1236            config.amdMachineKind = 1;
     1237        if (config.amdMachineMajor == BINGEN16_DEFAULT)
     1238            config.amdMachineMajor = amdGpuArchValues.major;
     1239        if (config.amdMachineMinor == BINGEN16_DEFAULT)
     1240            config.amdMachineMinor = amdGpuArchValues.minor;
     1241        if (config.amdMachineStepping == BINGEN16_DEFAULT)
     1242            config.amdMachineStepping = amdGpuArchValues.stepping;
     1243        if (config.kernelCodeEntryOffset == BINGEN64_DEFAULT)
     1244            config.kernelCodeEntryOffset = 256;
     1245        if (config.kernelCodePrefetchOffset == BINGEN64_DEFAULT)
     1246            config.kernelCodePrefetchOffset = 0;
     1247        if (config.kernelCodePrefetchSize == BINGEN64_DEFAULT)
     1248            config.kernelCodePrefetchSize = 0;
     1249        if (config.maxScrachBackingMemorySize == BINGEN64_DEFAULT) // ??
     1250            config.maxScrachBackingMemorySize = 0;
     1251       
     1252        if (config.scratchBufferSize == BINGEN_DEFAULT)
     1253            config.scratchBufferSize = 0;
     1254        if (config.workitemPrivateSegmentSize == BINGEN_DEFAULT)
     1255            config.workitemPrivateSegmentSize = config.scratchBufferSize;
     1256        if (config.localSize == BINGEN_DEFAULT)
     1257            config.localSize = 0;
     1258        if (config.workgroupGroupSegmentSize == BINGEN_DEFAULT)
     1259            config.workgroupGroupSegmentSize = config.localSize;
     1260        if (config.gdsSegmentSize == BINGEN_DEFAULT)
     1261            config.gdsSegmentSize = 0;
     1262        if (config.kernargSegmentSize == BINGEN64_DEFAULT)
     1263            config.kernargSegmentSize = 0;
     1264        if (config.workgroupFbarrierCount == BINGEN_DEFAULT)
     1265            config.workgroupFbarrierCount = 0;
     1266        if (config.reservedVgprFirst == BINGEN_DEFAULT)
     1267            config.reservedVgprFirst = 0;
     1268        if (config.reservedVgprCount == BINGEN_DEFAULT)
     1269            config.reservedVgprCount = 0;
     1270        if (config.reservedSgprFirst == BINGEN_DEFAULT)
     1271            config.reservedSgprFirst = 0;
     1272        if (config.reservedSgprCount == BINGEN_DEFAULT)
     1273            config.reservedSgprCount = 0;
     1274        if (config.debugWavefrontPrivateSegmentOffsetSgpr == BINGEN16_DEFAULT)
     1275            config.debugWavefrontPrivateSegmentOffsetSgpr = 0;
     1276        if (config.debugPrivateSegmentBufferSgpr == BINGEN16_DEFAULT)
     1277            config.debugPrivateSegmentBufferSgpr = 0;
     1278        if (config.kernargSegmentAlignment == BINGEN8_DEFAULT)
     1279            config.kernargSegmentAlignment = 4; // 16 bytes
     1280        if (config.groupSegmentAlignment == BINGEN8_DEFAULT)
     1281            config.groupSegmentAlignment = 4; // 16 bytes
     1282        if (config.privateSegmentAlignment == BINGEN8_DEFAULT)
     1283            config.privateSegmentAlignment = 4; // 16 bytes
     1284       
     1285        cxuint userSGPRsNum = 0;
     1286        if (config.userDataNum == BINGEN8_DEFAULT)
     1287        {   // calcuate userSGPRs
     1288            const uint16_t sgprFlags = config.enableSpgrRegisterFlags;
     1289            userSGPRsNum =
     1290                ((sgprFlags&1)!=0 ? 4 : 0) + /* use_private_segment_buffer */
     1291                ((sgprFlags&2)!=0 ? 2 : 0) + /* use_dispatch_ptr */
     1292                ((sgprFlags&4)!=0 ? 2 : 0) + /* use_queue_ptr */
     1293                ((sgprFlags&8)!=0 ? 2 : 0) + /* use_kernarg_segment_ptr */
     1294                ((sgprFlags&16)!=0 ? 2 : 0) + /* use_dispatch_id */
     1295                ((sgprFlags&32)!=0 ? 2 : 0) + /* use_flat_scratch_init */
     1296                ((sgprFlags&64)!=0) + /* use_private_segment_size */
     1297                /* use_grid_workgroup_count */
     1298                ((sgprFlags&128)!=0) + ((sgprFlags&256)!=0) + ((sgprFlags&128)!=0);
     1299        }
     1300        else // default
     1301            userSGPRsNum = config.userDataNum;
     1302       
    11791303        /* include userData sgprs */
    11801304        cxuint dimMask = (config.dimMask!=BINGEN_DEFAULT) ? config.dimMask :
     
    11951319            good = false;
    11961320        }
    1197        
     1321        // set usedSGPRsNum
    11981322        if (config.usedSGPRsNum==BINGEN_DEFAULT)
    11991323        {
     
    12031327                    maxSGPRsNum); // include all extra sgprs
    12041328        }
     1329        // set usedVGPRsNum
    12051330        if (config.usedVGPRsNum==BINGEN_DEFAULT)
    12061331            config.usedVGPRsNum = std::max(minRegsNum[1], kernelStates[i]->allocRegs[1]);
     1332       
     1333        cxuint sgprsNum = std::max(config.usedSGPRsNum, 1U);
     1334        cxuint vgprsNum = std::max(config.usedVGPRsNum, 1U);
     1335        // computePGMRSRC1
     1336        config.computePgmRsrc1 |= ((vgprsNum-1)>>2) |
     1337                (((sgprsNum-1)>>3)<<6) | ((uint32_t(config.floatMode)&0xff)<<12) |
     1338                (config.ieeeMode?1U<<23:0) | (uint32_t(config.priority&3)<<10) |
     1339                (config.privilegedMode?1U<<20:0) | (config.dx10Clamp?1U<<21:0) |
     1340                (config.debugMode?1U<<22:0);
     1341               
     1342        uint32_t dimValues = 0;
     1343        if (config.dimMask != BINGEN_DEFAULT)
     1344            dimValues = ((config.dimMask&7)<<7) |
     1345                    (((config.dimMask&4) ? 2 : (config.dimMask&2) ? 1 : 0)<<11);
     1346        else
     1347            dimValues |= (config.computePgmRsrc2 & 0x1b80U);
     1348        // computePGMRSRC2
     1349        config.computePgmRsrc2 = (config.computePgmRsrc2 & 0xffffe440U) |
     1350                        (config.userDataNum<<1) | ((config.tgSize) ? 0x400 : 0) |
     1351                        ((config.scratchBufferSize)?1:0) | dimValues |
     1352                        (((config.localSize+ldsMask)>>ldsShift)<<15) |
     1353                        ((uint32_t(config.exceptions)&0x7f)<<24);
     1354       
     1355        if (config.wavefrontSgprCount == BINGEN16_DEFAULT)
     1356            config.wavefrontSgprCount = sgprsNum;
     1357        if (config.workitemVgprCount == BINGEN16_DEFAULT)
     1358            config.workitemVgprCount = vgprsNum;
     1359       
     1360        if (config.callConvention == BINGEN_DEFAULT)
     1361            config.callConvention = 0;
     1362        if (config.runtimeLoaderKernelSymbol == BINGEN64_DEFAULT)
     1363            config.runtimeLoaderKernelSymbol = 0;
     1364       
    12071365        // to little endian
    12081366        SLEV(config.amdCodeVersionMajor, config.amdCodeVersionMajor);
     
    12421400    }
    12431401   
     1402    // if set adds symbols to binary
     1403    if (assembler.getFlags() & ASM_FORCE_ADD_SYMBOLS)
     1404        for (const AsmSymbolEntry& symEntry: assembler.symbolMap)
     1405        {
     1406            if (!symEntry.second.hasValue)
     1407                continue; // unresolved
     1408            if (ELF32_ST_BIND(symEntry.second.info) == STB_LOCAL)
     1409                continue; // local
     1410            if (ELF32_ST_BIND(symEntry.second.info) == STB_GLOBAL)
     1411            {
     1412                assembler.printError(AsmSourcePos(), (std::string("Added symbol '")+
     1413                    symEntry.first.c_str()+"' must not be a global").c_str());
     1414                good = false;
     1415                continue; // local
     1416            }
     1417            if (assembler.kernelMap.find(symEntry.first.c_str())!=assembler.kernelMap.end())
     1418                continue; // if kernel name
     1419            cxuint binSectId = (symEntry.second.sectionId != ASMSECT_ABS) ?
     1420                    sections[symEntry.second.sectionId].elfBinSectId : ELFSECTID_ABS;
     1421           
     1422            output.extraSymbols.push_back({ symEntry.first, symEntry.second.value,
     1423                    symEntry.second.size, binSectId, false, symEntry.second.info,
     1424                    symEntry.second.other });
     1425        }
     1426   
    12441427    const AsmSymbolMap& symbolMap = assembler.getSymbolMap();
    12451428    for (size_t ki = 0; ki < output.symbols.size(); ki++)
  • CLRadeonExtender/trunk/amdasm/DisasmROCm.cpp

    r2602 r2604  
    3636using namespace CLRX;
    3737
    38 struct AMDGPUArchValues
     38struct AMDGPUArchValuesEntry
    3939{
    4040    uint32_t major;
     
    4444};
    4545
    46 static const AMDGPUArchValues amdGpuArchValuesTbl[] =
     46static const AMDGPUArchValuesEntry amdGpuArchValuesTbl[] =
    4747{
    4848    { 0, 0, 0, GPUDeviceType::CAPE_VERDE },
  • CLRadeonExtender/trunk/amdbin/AmdCL2BinGen.cpp

    r2561 r2604  
    16311631    'c', 'o', 'n', 'v', 'e', 'n', 't', 'i', 'o', 'n', '=', '0', 0, 't' };
    16321632
    1633 struct AMDGPUArchValues
    1634 {
    1635     uint32_t major;
    1636     uint32_t minor;
    1637     uint32_t stepping;
    1638 };
    1639 
    16401633/* TODO: add gpu values tables for various driver version */
    16411634static const AMDGPUArchValues amdGpuArchValuesTbl[] =
  • CLRadeonExtender/trunk/amdbin/ROCmBinaries.cpp

    r2600 r2604  
    198198  'A', 'M', 'D', 0, 'A', 'M', 'D', 'G', 'P', 'U', 0 };
    199199
    200 struct AMDGPUArchValues
    201 {
    202     uint32_t major;
    203     uint32_t minor;
    204     uint32_t stepping;
    205 };
    206 
    207200// section index for symbol binding
    208201static const uint16_t mainBuiltinSectionTable[] =
     
    224217};
    225218
    226 static const AMDGPUArchValues amdGpuArchValuesTbl[] =
     219namespace CLRX
     220{
     221extern const AMDGPUArchValues rocmAmdGpuArchValuesTbl[];
     222}
     223
     224const AMDGPUArchValues CLRX::rocmAmdGpuArchValuesTbl[] =
    227225{
    228226    { 0, 0, 0 }, // GPUDeviceType::CAPE_VERDE
     
    252250             Array<cxbyte>* aPtr) const
    253251{
    254     AMDGPUArchValues amdGpuArchValues = amdGpuArchValuesTbl[cxuint(input->deviceType)];
     252    AMDGPUArchValues amdGpuArchValues = rocmAmdGpuArchValuesTbl[cxuint(input->deviceType)];
    255253    if (input->archMinor!=UINT32_MAX)
    256254        amdGpuArchValues.minor = input->archMinor;
Note: See TracChangeset for help on using the changeset viewer.