Changeset 2589 in CLRX


Ignore:
Timestamp:
Nov 21, 2016, 11:11:11 PM (3 years ago)
Author:
matszpk
Message:

CLRadeonExtender: AsmROCm: Add setting of config values (majority). Create and use AsmROCmKernelConfig with additional fields.

Location:
CLRadeonExtender/trunk
Files:
2 edited

Legend:

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

    r2587 r2589  
    418418};
    419419
     420struct AsmROCmKernelConfig: ROCmKernelConfig
     421{
     422    cxuint dimMask;    ///< mask of dimension (bits: 0 - X, 1 - Y, 2 - Z)
     423    cxuint usedVGPRsNum;  ///< number of used VGPRs
     424    cxuint usedSGPRsNum;  ///< number of used SGPRs
     425    cxbyte userDataNum;   ///< number of user data
     426    bool ieeeMode;  ///< IEEE mode
     427    cxbyte floatMode; ///< float mode
     428    cxbyte priority;    ///< priority
     429    cxbyte exceptions;      ///< enabled exceptions
     430    bool tgSize;        ///< enable TG_SIZE_EN bit
     431    bool debugMode;     ///< debug mode
     432    bool privilegedMode;   ///< prvileged mode
     433    bool dx10Clamp;     ///< DX10 CLAMP mode
     434    size_t localSize; ///< used local size (not local defined in kernel arguments)
     435    uint32_t scratchBufferSize; ///< size of scratch buffer
     436};
     437
    420438/// handles ROCM binary format
    421439class AsmROCmHandler: public AsmFormatHandler
     
    435453    {
    436454        cxuint configSection;
    437         std::unique_ptr<ROCmKernelConfig> config;
     455        std::unique_ptr<AsmROCmKernelConfig> config;
    438456        cxuint ctrlDirSection;
    439457        cxuint savedSection;
     
    443461        void initializeKernelConfig();
    444462    };
    445     std::vector<Kernel> kernelStates;
     463    std::vector<Kernel*> kernelStates;
    446464    std::vector<Section> sections;
    447465    std::vector<cxuint> kcodeSelection; // kcode
     
    462480    explicit AsmROCmHandler(Assembler& assembler);
    463481    /// destructor
    464     ~AsmROCmHandler() = default;
     482    ~AsmROCmHandler();
    465483   
    466484    cxuint addKernel(const char* kernelName);
  • CLRadeonExtender/trunk/amdasm/AsmROCmFormat.cpp

    r2588 r2589  
    104104}
    105105
     106AsmROCmHandler::~AsmROCmHandler()
     107{
     108    for (Kernel* kernel: kernelStates)
     109        delete kernel;
     110}
     111
    106112cxuint AsmROCmHandler::addKernel(const char* kernelName)
    107113{
     
    111117    /// add kernel config section
    112118    sections.push_back({ thisKernel, AsmSectionType::CONFIG, ELFSECTID_UNDEF, nullptr });
    113     kernelStates.push_back({ thisSection, nullptr, ASMSECT_NONE, thisSection });
     119    kernelStates.push_back(new Kernel{ thisSection, nullptr, ASMSECT_NONE, thisSection });
    114120   
    115121    if (assembler.currentKernel == ASMKERN_GLOBAL)
     
    186192        savedSection = assembler.currentSection;
    187193    else // if kernel
    188         kernelStates[assembler.currentKernel].savedSection = assembler.currentSection;
     194        kernelStates[assembler.currentKernel]->savedSection = assembler.currentSection;
    189195   
    190196    assembler.currentKernel = kernel;
    191197    if (kernel != ASMKERN_GLOBAL)
    192         assembler.currentSection = kernelStates[kernel].savedSection;
     198        assembler.currentSection = kernelStates[kernel]->savedSection;
    193199    else // default main section
    194200        assembler.currentSection = savedSection;
     
    203209        savedSection = assembler.currentSection;
    204210    else // if kernel
    205         kernelStates[assembler.currentKernel].savedSection = assembler.currentSection;
     211        kernelStates[assembler.currentKernel]->savedSection = assembler.currentSection;
    206212   
    207213    assembler.currentSection = sectionId;
     
    231237    if (currentKcodeKernel != ASMKERN_GLOBAL)
    232238    {
    233         Kernel& newKernel = kernelStates[currentKcodeKernel];
     239        Kernel& newKernel = *kernelStates[currentKcodeKernel];
    234240        assembler.isaAssembler->setAllocatedRegisters(newKernel.allocRegs,
    235241                            newKernel.allocRegFlags);
     
    242248    {   // save other state
    243249        size_t regTypesNum;
    244         Kernel& oldKernel = kernelStates[currentKcodeKernel];
     250        Kernel& oldKernel = *kernelStates[currentKcodeKernel];
    245251        const cxuint* regs = assembler.isaAssembler->getAllocatedRegisters(
    246252                            regTypesNum, oldKernel.allocRegFlags);
     
    270276    if (!config)
    271277    {
    272         config.reset(new ROCmKernelConfig{});
    273         ::memset(config.get(), 0, sizeof(ROCmKernelConfig));
     278        config.reset(new AsmROCmKernelConfig{});
     279        ::memset(config.get(), 0, sizeof(AsmROCmKernelConfig));
    274280    }
    275281}
     
    307313    if (!checkGarbagesAtEnd(asmr, linePtr))
    308314        return;
    309     handler.kernelStates[asmr.currentKernel].initializeKernelConfig();
     315    handler.kernelStates[asmr.currentKernel]->initializeKernelConfig();
    310316}
    311317
     
    325331        return;
    326332   
    327     AsmROCmHandler::Kernel& kernel = handler.kernelStates[asmr.currentKernel];
     333    AsmROCmHandler::Kernel& kernel = *handler.kernelStates[asmr.currentKernel];
    328334    if (kernel.ctrlDirSection == ASMSECT_NONE)
    329335    {
     
    335341    }
    336342    asmr.goToSection(pseudoOpPlace, kernel.ctrlDirSection);
    337     handler.kernelStates[asmr.currentKernel].initializeKernelConfig();
     343    handler.kernelStates[asmr.currentKernel]->initializeKernelConfig();
    338344}
    339345
     
    341347                  const char* linePtr, ROCmConfigValueTarget target)
    342348{
     349    Assembler& asmr = handler.assembler;
     350    const char* end = asmr.line + asmr.lineSize;
     351   
     352    if (asmr.currentKernel==ASMKERN_GLOBAL ||
     353        asmr.sections[asmr.currentSection].type != AsmSectionType::CONFIG)
     354    {
     355        asmr.printError(pseudoOpPlace, "Illegal place of configuration pseudo-op");
     356        return;
     357    }
     358   
     359    skipSpacesToEnd(linePtr, end);
     360    const char* valuePlace = linePtr;
     361    uint64_t value = BINGEN_NOTSUPPLIED;
     362    bool good = getAbsoluteValueArg(asmr, value, linePtr, true);
     363    /* ranges checking */
     364    if (good)
     365    {
     366        switch(target)
     367        {
     368            case ROCMCVAL_SGPRSNUM:
     369            {
     370                const GPUArchitecture arch = getGPUArchitectureFromDeviceType(
     371                            asmr.deviceType);
     372                cxuint maxSGPRsNum = getGPUMaxRegistersNum(arch, REGTYPE_SGPR, 0);
     373                if (value > maxSGPRsNum)
     374                {
     375                    char buf[64];
     376                    snprintf(buf, 64, "Used SGPRs number out of range (0-%u)", maxSGPRsNum);
     377                    asmr.printError(valuePlace, buf);
     378                    good = false;
     379                }
     380                break;
     381            }
     382            case ROCMCVAL_VGPRSNUM:
     383            {
     384                const GPUArchitecture arch = getGPUArchitectureFromDeviceType(
     385                            asmr.deviceType);
     386                cxuint maxVGPRsNum = getGPUMaxRegistersNum(arch, REGTYPE_VGPR, 0);
     387                if (value > maxVGPRsNum)
     388                {
     389                    char buf[64];
     390                    snprintf(buf, 64, "Used VGPRs number out of range (0-%u)", maxVGPRsNum);
     391                    asmr.printError(valuePlace, buf);
     392                    good = false;
     393                }
     394                break;
     395            }
     396            case ROCMCVAL_EXCEPTIONS:
     397                asmr.printWarningForRange(7, value,
     398                                  asmr.getSourcePos(valuePlace), WS_UNSIGNED);
     399                value &= 0x7f;
     400                break;
     401            case ROCMCVAL_FLOATMODE:
     402                asmr.printWarningForRange(8, value,
     403                                  asmr.getSourcePos(valuePlace), WS_UNSIGNED);
     404                value &= 0xff;
     405                break;
     406            case ROCMCVAL_PRIORITY:
     407                asmr.printWarningForRange(2, value,
     408                                  asmr.getSourcePos(valuePlace), WS_UNSIGNED);
     409                value &= 3;
     410                break;
     411            case ROCMCVAL_LOCALSIZE:
     412            {
     413                const GPUArchitecture arch = getGPUArchitectureFromDeviceType(
     414                            asmr.deviceType);
     415                const cxuint maxLocalSize = getGPUMaxLocalSize(arch);
     416                if (value > maxLocalSize)
     417                {
     418                    char buf[64];
     419                    snprintf(buf, 64, "LocalSize out of range (0-%u)", maxLocalSize);
     420                    asmr.printError(valuePlace, buf);
     421                    good = false;
     422                }
     423                break;
     424            }
     425            case ROCMCVAL_USERDATANUM:
     426                if (value > 16)
     427                {
     428                    asmr.printError(valuePlace, "UserDataNum out of range (0-16)");
     429                    good = false;
     430                }
     431                break;
     432            default:
     433                break;
     434        }
     435    }
     436    if (!good || !checkGarbagesAtEnd(asmr, linePtr))
     437        return;
     438   
     439    handler.kernelStates[asmr.currentKernel]->initializeKernelConfig();
     440    AsmROCmKernelConfig& config = *(handler.kernelStates[asmr.currentKernel]->config);
     441    // set value
     442    switch(target)
     443    {
     444        case ROCMCVAL_SGPRSNUM:
     445            config.usedSGPRsNum = value;
     446            break;
     447        case ROCMCVAL_VGPRSNUM:
     448            config.usedVGPRsNum = value;
     449            break;
     450        case ROCMCVAL_PGMRSRC1:
     451            config.computePgmRsrc1 = value;
     452            break;
     453        case ROCMCVAL_PGMRSRC2:
     454            config.computePgmRsrc2 = value;
     455            break;
     456        case ROCMCVAL_FLOATMODE:
     457            config.floatMode = value;
     458            break;
     459        case ROCMCVAL_LOCALSIZE:
     460            config.localSize = value;
     461            break;
     462        case ROCMCVAL_SCRATCHBUFFER:
     463            config.scratchBufferSize = value;
     464            break;
     465        case ROCMCVAL_PRIORITY:
     466            config.priority = value;
     467            break;
     468        case ROCMCVAL_USERDATANUM:
     469            config.userDataNum = value;
     470            break;
     471        case ROCMCVAL_EXCEPTIONS:
     472            config.exceptions = value;
     473            break;
     474        case ROCMCVAL_KERNEL_CODE_ENTRY_OFFSET:
     475            config.kernelCodeEntryOffset = value;
     476            break;
     477        case ROCMCVAL_KERNEL_CODE_PREFETCH_OFFSET:
     478            config.kernelCodePrefetchOffset = value;
     479            break;
     480        case ROCMCVAL_KERNEL_CODE_PREFETCH_SIZE:
     481            config.kernelCodePrefetchSize = value;
     482            break;
     483        case ROCMCVAL_MAX_SCRATCH_BACKING_MEMORY:
     484            config.maxScrachBackingMemorySize = value;
     485            break;
     486        case ROCMCVAL_WORKITEM_PRIVATE_SEGMENT_SIZE:
     487            config.workitemPrivateSegmentSize = value;
     488            break;
     489        case ROCMCVAL_WORKGROUP_GROUP_SEGMENT_SIZE:
     490            config.workgroupGroupSegmentSize = value;
     491            break;
     492        case ROCMCVAL_GDS_SEGMENT_SIZE:
     493            config.gdsSegmentSize = value;
     494            break;
     495        case ROCMCVAL_KERNARG_SEGMENT_SIZE:
     496            config.kernargSegmentSize = value;
     497            break;
     498        case ROCMCVAL_WORKGROUP_FBARRIER_COUNT:
     499            config.workgroupFbarrierCount = value;
     500            break;
     501        case ROCMCVAL_WAVEFRONT_SGPR_COUNT:
     502            config.wavefrontSgprCount = value;
     503            break;
     504        case ROCMCVAL_WORKITEM_VGPR_COUNT:
     505            config.workitemVgprCount = value;
     506            break;
     507        case ROCMCVAL_RESERVED_VGPR_FIRST:
     508            config.reservedVgprFirst = value;
     509            break;
     510        case ROCMCVAL_RESERVED_VGPR_COUNT:
     511            config.reservedVgprCount = value;
     512            break;
     513        case ROCMCVAL_RESERVED_SGPR_FIRST:
     514            config.reservedSgprFirst = value;
     515            break;
     516        case ROCMCVAL_RESERVED_SGPR_COUNT:
     517            config.reservedSgprCount = value;
     518            break;
     519        case ROCMCVAL_DEBUG_WAVEFRONT_PRIVATE_SEGMENT_OFFSET_SGPR:
     520            config.debugWavefrontPrivateSegmentOffsetSgpr = value;
     521            break;
     522        case ROCMCVAL_DEBUG_PRIVATE_SEGMENT_BUFFER_SGPR:
     523            config.debugPrivateSegmentBufferSgpr = value;
     524            break;
     525        case ROCMCVAL_KERNARG_SEGMENT_ALIGN:
     526            config.kernargSegmentAlignment = value;
     527            break;
     528        case ROCMCVAL_GROUP_SEGMENT_ALIGN:
     529            config.groupSegmentAlignment = value;
     530            break;
     531        case ROCMCVAL_PRIVATE_SEGMENT_ALIGN:
     532            config.privateSegmentAlignment = value;
     533            break;
     534        case ROCMCVAL_WAVEFRONT_SIZE:
     535            config.wavefrontSize = value;
     536            break;
     537        case ROCMCVAL_CALL_CONVENTION:
     538            config.callConvention = value;
     539            break;
     540        case ROCMCVAL_RUNTIME_LOADER_KERNEL_SYMBOL:
     541            config.runtimeLoaderKernelSymbol = value;
     542            break;
     543        default:
     544            break;
     545    }
    343546}
    344547
Note: See TracChangeset for help on using the changeset viewer.