Changeset 2522 in CLRX


Ignore:
Timestamp:
Nov 1, 2016, 9:25:54 PM (3 years ago)
Author:
matszpk
Message:

CLRadeonExtender: Disasm: add dump of kernel config for ROCm binaries.

Location:
CLRadeonExtender/trunk
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • CLRadeonExtender/trunk/CLRX/amdbin/ROCmBinaries.h

    r2518 r2522  
    9696};
    9797
     98/// ROCm kernel configuration structure
     99struct ROCmKernelConfig
     100{
     101    uint32_t amdCodeVersionMajor;
     102    uint32_t amdCodeVersionMinor;
     103    uint16_t amdMachineKind;
     104    uint16_t amdMachineMajor;
     105    uint16_t amdMachineMinor;
     106    uint16_t amdMachineStepping;
     107    uint64_t kernelCodeEntryOffset;
     108    uint64_t kernelCodePrefetchOffset;
     109    uint64_t kernelCodePrefetchSize;
     110    uint64_t maxScrachBackingMemorySize;
     111    uint32_t computePgmRsrc1;
     112    uint32_t computePgmRsrc2;
     113    uint16_t enableSpgrRegisterFlags;
     114    uint16_t enableFeatureFlags;
     115    uint32_t workitemPrivateSegmentSize;
     116    uint32_t workgroupGroupSegmentSize;
     117    uint32_t gdsSegmentSize;
     118    uint64_t kernargSegmentSize;
     119    uint32_t workgroupFbarrierCount;
     120    uint16_t wavefrontSgprCount;
     121    uint16_t workitemVgprCount;
     122    uint16_t reservedVgprFirst;
     123    uint16_t reservedVgprCount;
     124    uint16_t reservedSgprFirst;
     125    uint16_t reservedSgprCount;
     126    uint16_t debugWavefrontPrivateSegmentOffsetSgpr;
     127    uint16_t debugPrivateSegmentBufferSgpr;
     128    cxbyte kernargSegmentAlignment;
     129    cxbyte groupSegmentAlignment;
     130    cxbyte privateSegmentAlignment;
     131    cxbyte wavefrontSize;
     132    uint32_t callConvention;
     133    uint32_t reserved1[3];
     134    uint64_t runtimeLoaderKernelSymbol;
     135    cxbyte controlDirective[128];
     136};
     137
    98138/// check whether is Amd OpenCL 2.0 binary
    99139extern bool isROCmBinary(size_t binarySize, const cxbyte* binary);
  • CLRadeonExtender/trunk/amdasm/DisasmROCm.cpp

    r2520 r2522  
    2222#include <cstdint>
    2323#include <cstdio>
     24#include <inttypes.h>
    2425#include <string>
    2526#include <ostream>
     
    124125}
    125126
     127static void dumpKernelConfig(std::ostream& output, cxuint maxSgprsNum,
     128             GPUArchitecture arch, const ROCmKernelConfig& config)
     129{
     130    output.write("    .config\n", 12);
     131    size_t bufSize;
     132    char buf[100];
     133    const cxuint ldsShift = arch<GPUArchitecture::GCN1_1 ? 8 : 9;
     134    const uint32_t pgmRsrc1 = config.computePgmRsrc1;
     135    const uint32_t pgmRsrc2 = config.computePgmRsrc2;
     136   
     137    const cxuint dimMask = (pgmRsrc2 >> 7) & 7;
     138    strcpy(buf, "        .dims ");
     139    bufSize = 14;
     140    if ((dimMask & 1) != 0)
     141        buf[bufSize++] = 'x';
     142    if ((dimMask & 2) != 0)
     143        buf[bufSize++] = 'y';
     144    if ((dimMask & 4) != 0)
     145        buf[bufSize++] = 'z';
     146    buf[bufSize++] = '\n';
     147    output.write(buf, bufSize);
     148   
     149    bufSize = snprintf(buf, 100, "        .sgprsnum %u\n",
     150              std::min((((pgmRsrc1>>6) & 0xf)<<3)+8, maxSgprsNum));
     151    output.write(buf, bufSize);
     152    bufSize = snprintf(buf, 100, "        .vgprsnum %u\n", ((pgmRsrc1 & 0x3f)<<2)+4);
     153    output.write(buf, bufSize);
     154    output.write(buf, bufSize);
     155    if ((pgmRsrc1 & (1U<<20)) != 0)
     156        output.write("        .privmode\n", 18);
     157    if ((pgmRsrc1 & (1U<<22)) != 0)
     158        output.write("        .debugmode\n", 19);
     159    if ((pgmRsrc1 & (1U<<21)) != 0)
     160        output.write("        .dx10clamp\n", 19);
     161    if ((pgmRsrc1 & (1U<<23)) != 0)
     162        output.write("        .ieeemode\n", 18);
     163    if ((pgmRsrc2 & 0x400) != 0)
     164        output.write("        .tgsize\n", 16);
     165   
     166    bufSize = snprintf(buf, 100, "        .floatmode 0x%02x\n", (pgmRsrc1>>12) & 0xff);
     167    output.write(buf, bufSize);
     168    bufSize = snprintf(buf, 100, "        .priority %u\n", (pgmRsrc1>>10) & 3);
     169    output.write(buf, bufSize);
     170    if (((pgmRsrc1>>24) & 0x7f) != 0)
     171    {
     172        bufSize = snprintf(buf, 100, "        .exceptions 0x%02x\n",
     173                   (pgmRsrc1>>24) & 0x7f);
     174        output.write(buf, bufSize);
     175    }
     176    const cxuint localSize = ((pgmRsrc2>>15) & 0x1ff) << ldsShift;
     177    if (localSize!=0)
     178    {
     179        bufSize = snprintf(buf, 100, "        .localsize %u\n", localSize);
     180        output.write(buf, bufSize);
     181    }
     182    bufSize = snprintf(buf, 100, "        .userdatanum %u\n", (pgmRsrc2>>1) & 0x1f);
     183    output.write(buf, bufSize);
     184   
     185    bufSize = snprintf(buf, 100, "        .pgmrsrc1 0x%08x\n", pgmRsrc1);
     186    output.write(buf, bufSize);
     187    bufSize = snprintf(buf, 100, "        .pgmrsrc2 0x%08x\n", pgmRsrc2);
     188    output.write(buf, bufSize);
     189   
     190    bufSize = snprintf(buf, 100, "        .codeversion %u, %u\n",
     191                   config.amdCodeVersionMajor, config.amdCodeVersionMinor);
     192    output.write(buf, bufSize);
     193    bufSize = snprintf(buf, 100, "        .machine %hu, %hu, %hu, %hu\n",
     194                   config.amdMachineKind, config.amdMachineMajor,
     195                   config.amdMachineMinor, config.amdMachineStepping);
     196    output.write(buf, bufSize);
     197    bufSize = snprintf(buf, 100, "        .kernel_code_entry_offset 0x%" PRIx64 "\n",
     198                       config.kernelCodeEntryOffset);
     199    output.write(buf, bufSize);
     200    if (config.kernelCodePrefetchOffset!=0)
     201    {
     202        bufSize = snprintf(buf, 100,
     203                   "        .kernel_code_prefetch_offset 0x%" PRIx64 "\n",
     204                           config.kernelCodePrefetchOffset);
     205        output.write(buf, bufSize);
     206    }
     207    if (config.kernelCodePrefetchSize!=0)
     208    {
     209        bufSize = snprintf(buf, 100, "        .kernel_code_prefetch_size %" PRIu64 "\n",
     210                           config.kernelCodePrefetchSize);
     211        output.write(buf, bufSize);
     212    }
     213    if (config.maxScrachBackingMemorySize!=0)
     214    {
     215        bufSize = snprintf(buf, 100, "        .max_scratch_backing_memory %" PRIu64 "\n",
     216                           config.maxScrachBackingMemorySize);
     217        output.write(buf, bufSize);
     218    }
     219   
     220    const uint16_t sgprFlags = config.enableSpgrRegisterFlags;
     221    if ((sgprFlags&1) != 0)
     222        output.write("        .use_private_segment_buffer\n", 36);
     223    if ((sgprFlags&2) != 0)
     224        output.write("        .use_dispatch_ptr\n", 26);
     225    if ((sgprFlags&4) != 0)
     226        output.write("        .use_queue_ptr\n", 24);
     227    if ((sgprFlags&8) != 0)
     228        output.write("        .use_kernarg_segment_ptr\n", 33);
     229    if ((sgprFlags&16) != 0)
     230        output.write("        .use_dispatch_id\n", 25);
     231    if ((sgprFlags&32) != 0)
     232        output.write("        .use_flat_scratch_init\n", 31);
     233    if ((sgprFlags&64) != 0)
     234        output.write("        .use_private_segment_size\n", 34);
     235    if ((sgprFlags&128) != 0)
     236        output.write("        .use_grid_workgroup_count_x\n", 36);
     237    if ((sgprFlags&256) != 0)
     238        output.write("        .use_grid_workgroup_count_y\n", 36);
     239    if ((sgprFlags&512) != 0)
     240        output.write("        .use_grid_workgroup_count_z\n", 36);
     241    const uint16_t featureFlags = config.enableFeatureFlags;
     242    if ((featureFlags&1) != 0)
     243        output.write("        .use_ordered_append_gds\n", 32);
     244    bufSize = snprintf(buf, 100, "        .private_elem_size %u\n",
     245                       2U<<((featureFlags>>1)&3));
     246    output.write(buf, bufSize);
     247    if ((featureFlags&8) != 0)
     248        output.write("        .use_ptr64\n", 19);
     249    if ((featureFlags&16) != 0)
     250        output.write("        .use_dynamic_call_stack\n", 32);
     251    if ((featureFlags&32) != 0)
     252        output.write("        .use_debug_enabled\n", 27);
     253    if ((featureFlags&64) != 0)
     254        output.write("        .use_xnack_enabled\n", 27);
     255   
     256    if (config.workitemPrivateSegmentSize!=0)
     257    {
     258        bufSize = snprintf(buf, 100, "        .workitem_private_segment_size %u\n",
     259                         config.workitemPrivateSegmentSize);
     260        output.write(buf, bufSize);
     261    }
     262    if (config.workgroupGroupSegmentSize!=0)
     263    {
     264        bufSize = snprintf(buf, 100, "        .workgroup_group_segment_size %u\n",
     265                         config.workgroupGroupSegmentSize);
     266        output.write(buf, bufSize);
     267    }
     268    if (config.gdsSegmentSize!=0)
     269    {
     270        bufSize = snprintf(buf, 100, "        .gds_segment_size %u\n",
     271                         config.gdsSegmentSize);
     272        output.write(buf, bufSize);
     273    }
     274    if (config.kernargSegmentSize!=0)
     275    {
     276        bufSize = snprintf(buf, 100, "        .kernarg_segment_size %" PRIu64 "\n",
     277                         config.kernargSegmentSize);
     278        output.write(buf, bufSize);
     279    }
     280    if (config.workgroupFbarrierCount!=0)
     281    {
     282        bufSize = snprintf(buf, 100, "        .workgroup_fbarrier_count %u\n",
     283                         config.workgroupFbarrierCount);
     284        output.write(buf, bufSize);
     285    }
     286    if (config.wavefrontSgprCount!=0)
     287    {
     288        bufSize = snprintf(buf, 100, "        .wavefront_sgpr_count %hu\n",
     289                         config.wavefrontSgprCount);
     290        output.write(buf, bufSize);
     291    }
     292    if (config.workitemVgprCount!=0)
     293    {
     294        bufSize = snprintf(buf, 100, "        .workitem_vgpr_count %hu\n",
     295                         config.workitemVgprCount);
     296        output.write(buf, bufSize);
     297    }
     298    if (config.reservedVgprFirst!=0)
     299    {
     300        bufSize = snprintf(buf, 100, "        .reserved_vgpr_first %hu\n",
     301                         config.reservedVgprFirst);
     302        output.write(buf, bufSize);
     303    }
     304    if (config.reservedVgprCount!=0)
     305    {
     306        bufSize = snprintf(buf, 100, "        .reserved_vgpr_count %hu\n",
     307                         config.reservedVgprCount);
     308        output.write(buf, bufSize);
     309    }
     310    if (config.reservedSgprFirst!=0)
     311    {
     312        bufSize = snprintf(buf, 100, "        .reserved_sgpr_first %hu\n",
     313                         config.reservedSgprFirst);
     314        output.write(buf, bufSize);
     315    }
     316    if (config.reservedSgprCount!=0)
     317    {
     318        bufSize = snprintf(buf, 100, "        .reserved_sgpr_count %hu\n",
     319                         config.reservedSgprCount);
     320        output.write(buf, bufSize);
     321    }
     322    if (config.debugWavefrontPrivateSegmentOffsetSgpr!=0)
     323    {
     324        bufSize = snprintf(buf, 100, "        "
     325                        ".debug_wavefront_private_segment_offset_sgpr %hu\n",
     326                         config.debugWavefrontPrivateSegmentOffsetSgpr);
     327        output.write(buf, bufSize);
     328    }
     329    if (config.debugPrivateSegmentBufferSgpr!=0)
     330    {
     331        bufSize = snprintf(buf, 100, "        .debug_private_segment_buffer_sgpr %hu\n",
     332                         config.debugPrivateSegmentBufferSgpr);
     333        output.write(buf, bufSize);
     334    }
     335    bufSize = snprintf(buf, 100, "        .kernarg_segment_align %u\n",
     336                     1U<<(config.kernargSegmentAlignment));
     337    output.write(buf, bufSize);
     338    bufSize = snprintf(buf, 100, "        .group_segment_align %u\n",
     339                     1U<<(config.groupSegmentAlignment));
     340    output.write(buf, bufSize);
     341    bufSize = snprintf(buf, 100, "        .private_segment_align %u\n",
     342                     1U<<(config.privateSegmentAlignment));
     343    output.write(buf, bufSize);
     344    bufSize = snprintf(buf, 100, "        .wavefront_size %u\n",
     345                     1U<<(config.wavefrontSize));
     346    output.write(buf, bufSize);
     347    bufSize = snprintf(buf, 100, "        .call_convention 0x%x\n",
     348                     config.callConvention);
     349    output.write(buf, bufSize);
     350    if (config.runtimeLoaderKernelSymbol!=0)
     351    {
     352        bufSize = snprintf(buf, 100,
     353                   "        .runtime_loader_kernel_symbol 0x%" PRIx64 "\n",
     354                         config.runtimeLoaderKernelSymbol);
     355        output.write(buf, bufSize);
     356    }
     357}
     358
    126359void CLRX::disassembleROCm(std::ostream& output, const ROCmDisasmInput* rocmInput,
    127360           ISADisassembler* isaDisassembler, size_t& sectionCount, Flags flags)
     
    132365    const bool doDumpConfig = ((flags & DISASM_CONFIG) != 0);
    133366   
    134     for (cxuint i = 0; i < rocmInput->regions.size(); i++)
    135     {
    136         const ROCmDisasmRegionInput& rinput = rocmInput->regions[i];
     367    const GPUArchitecture arch = getGPUArchitectureFromDeviceType(rocmInput->deviceType);
     368    const cxuint maxSgprsNum = getGPUMaxRegistersNum(arch, REGTYPE_SGPR, 0);
     369   
     370    for (const ROCmDisasmRegionInput& rinput: rocmInput->regions)
    137371        if (rinput.isKernel)
    138372        {
     
    140374            output.write(rinput.regionName.c_str(), rinput.regionName.size());
    141375            output.put('\n');
     376            if (doMetadata && doDumpConfig)
     377                dumpKernelConfig(output, maxSgprsNum, arch,
     378                     *reinterpret_cast<const ROCmKernelConfig*>(
     379                             rocmInput->code + rinput.offset));
    142380        }
    143     }
    144381   
    145382    const size_t regionsNum = rocmInput->regions.size();
     
    161398            if (region.isKernel)
    162399            {
    163                 if (doMetadata && !doDumpConfig)
    164                     printDisasmData(0x100, code + region.offset, output, true);
     400                if (doMetadata)
     401                {
     402                    if (!doDumpConfig)
     403                        printDisasmData(0x100, code + region.offset, output, true);
     404                    else
     405                        output.write(".skip 256\n", 10);
     406                }
    165407                if (doDumpCode)
    166408                {
  • CLRadeonExtender/trunk/amdbin/ROCmBinaries.cpp

    r2521 r2522  
    7474       
    7575        const cxbyte symType = ELF64_ST_TYPE(sym.st_info);
    76         if ((symType==STT_GNU_IFUNC || symType==STT_OBJECT))
     76        if (symType==STT_GNU_IFUNC || symType==STT_OBJECT)
    7777        {
    7878            const bool isKernel = (symType==STT_GNU_IFUNC);
Note: See TracChangeset for help on using the changeset viewer.