Changeset 2492 in CLRX


Ignore:
Timestamp:
Oct 8, 2016, 5:57:05 PM (4 years ago)
Author:
matszpk
Message:

CLRadeonExtender: Add a missing arch minor and stepping to AmdCL2 binary format.

Location:
CLRadeonExtender/trunk
Files:
9 edited

Legend:

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

    r2469 r2492  
    230230{
    231231    GPUDeviceType deviceType;   ///< GPU device type
     232    uint32_t archMinor;     ///< GPU arch minor
     233    uint32_t archStepping;     ///< GPU arch stepping
    232234    cxuint driverVersion; ///< driver version
    233235    CString compileOptions; ///< compile options which used by in clBuildProgram
  • CLRadeonExtender/trunk/CLRX/amdbin/AmdCL2BinGen.h

    r2386 r2492  
    113113{
    114114    GPUDeviceType deviceType;   ///< GPU device type
     115    uint32_t archMinor;            /// arch minor
     116    uint32_t archStepping;         /// arch stepping
    115117    size_t globalDataSize;  ///< global constant data size
    116118    const cxbyte* globalData;   ///< global constant data
     
    154156    /**
    155157     * \param deviceType GPU device type
     158     * \param archMinor architecture minor
     159     * \param archStepping architecture minor
    156160     * \param driverVersion number of driver version (majorVersion*100 + minorVersion)
    157161     * \param globalDataSize size of constant global data
     
    161165     * \param kernelInputs array of kernel inputs
    162166     */
    163     AmdCL2GPUBinGenerator(GPUDeviceType deviceType, uint32_t driverVersion,
     167    AmdCL2GPUBinGenerator(GPUDeviceType deviceType,
     168           uint32_t archMinor, uint32_t archStepping, uint32_t driverVersion,
    164169           size_t globalDataSize, const cxbyte* globalData,
    165170           size_t rwDataSize, const cxbyte* rwData,
    166171           const std::vector<AmdCL2KernelInput>& kernelInputs);
    167172    /// constructor
    168     AmdCL2GPUBinGenerator(GPUDeviceType deviceType, uint32_t driverVersion,
     173    AmdCL2GPUBinGenerator(GPUDeviceType deviceType,
     174           uint32_t archMinor, uint32_t archStepping, uint32_t driverVersion,
    169175           size_t globalDataSize, const cxbyte* globalData,
    170176           size_t rwDataSize, const cxbyte* rwData,
  • CLRadeonExtender/trunk/amdasm/AsmAmdCL2Format.cpp

    r2377 r2492  
    3434static const char* amdCL2PseudoOpNamesTbl[] =
    3535{
    36     "acl_version", "arg", "bssdata", "compile_options", "config",
     36    "acl_version", "arch_minor", "arch_stepping",
     37    "arg", "bssdata", "compile_options", "config",
    3738    "cws", "debugmode", "dims", "driver_version", "dx10clamp", "exceptions",
    3839    "floatmode", "get_driver_version", "globaldata", "ieeemode", "inner",
     
    4647enum
    4748{
    48     AMDCL2OP_ACL_VERSION = 0, AMDCL2OP_ARG, AMDCL2OP_BSSDATA, AMDCL2OP_COMPILE_OPTIONS,
     49    AMDCL2OP_ACL_VERSION = 0, AMDCL2OP_ARCH_MINOR, AMDCL2OP_ARCH_STEPPING,
     50    AMDCL2OP_ARG, AMDCL2OP_BSSDATA, AMDCL2OP_COMPILE_OPTIONS,
    4951    AMDCL2OP_CONFIG, AMDCL2OP_CWS, AMDCL2OP_DEBUGMODE, AMDCL2OP_DIMS,
    5052    AMDCL2OP_DRIVER_VERSION, AMDCL2OP_DX10CLAMP, AMDCL2OP_EXCEPTIONS,
     
    348350        return;
    349351    handler.output.aclVersion = out;
     352}
     353
     354void AsmAmdCL2PseudoOps::setArchMinor(AsmAmdCL2Handler& handler, const char* linePtr)
     355{
     356    Assembler& asmr = handler.assembler;
     357    const char* end = asmr.line + asmr.lineSize;
     358    skipSpacesToEnd(linePtr, end);
     359    uint64_t value;
     360    if (!getAbsoluteValueArg(asmr, value, linePtr, true))
     361        return;
     362    if (!checkGarbagesAtEnd(asmr, linePtr))
     363        return;
     364    handler.output.archMinor = value;
     365}
     366
     367void AsmAmdCL2PseudoOps::setArchStepping(AsmAmdCL2Handler& handler, const char* linePtr)
     368{
     369    Assembler& asmr = handler.assembler;
     370    const char* end = asmr.line + asmr.lineSize;
     371    skipSpacesToEnd(linePtr, end);
     372    uint64_t value;
     373    if (!getAbsoluteValueArg(asmr, value, linePtr, true))
     374        return;
     375    if (!checkGarbagesAtEnd(asmr, linePtr))
     376        return;
     377    handler.output.archStepping = value;
    350378}
    351379
     
    11641192        case AMDCL2OP_ACL_VERSION:
    11651193            AsmAmdCL2PseudoOps::setAclVersion(*this, linePtr);
     1194            break;
     1195        case AMDCL2OP_ARCH_MINOR:
     1196            AsmAmdCL2PseudoOps::setArchMinor(*this, linePtr);
     1197            break;
     1198        case AMDCL2OP_ARCH_STEPPING:
     1199            AsmAmdCL2PseudoOps::setArchStepping(*this, linePtr);
    11661200            break;
    11671201        case AMDCL2OP_ARG:
  • CLRadeonExtender/trunk/amdasm/AsmInternals.h

    r2484 r2492  
    464464    static bool checkPseudoOpName(const CString& string);
    465465   
     466    static void setArchMinor(AsmAmdCL2Handler& handler, const char* linePtr);
     467    static void setArchStepping(AsmAmdCL2Handler& handler, const char* linePtr);
     468   
    466469    static void setAclVersion(AsmAmdCL2Handler& handler, const char* linePtr);
    467470    static void setCompileOptions(AsmAmdCL2Handler& handler, const char* linePtr);
  • CLRadeonExtender/trunk/amdasm/DisasmAmdCL2.cpp

    r2390 r2492  
    148148   
    149149    input->deviceType = gpuCodeTable[index].deviceType;
     150    input->archMinor = 0;
     151    input->archStepping = 0;
    150152    input->compileOptions = binary.getCompileOptions();
    151153    input->aclVersionString = binary.getAclVersionString();
     
    179181        input->bssAlignment = innerBin.getBssAlignment();
    180182        input->bssSize = innerBin.getBssSize();
     183       
     184        {
     185            const cxbyte* noteContent = innerBin.getSectionContent(".note");
     186            size_t notesSize = innerBin.getSectionHeader(".note").sh_size;
     187            // find note about AMDGPU
     188            for (size_t offset = 0; offset < notesSize; )
     189            {
     190                const Elf64_Nhdr* nhdr = (const Elf64_Nhdr*)(noteContent + offset);
     191                size_t namesz = ULEV(nhdr->n_namesz);
     192                size_t descsz = ULEV(nhdr->n_descsz);
     193                if (ULEV(nhdr->n_type) == 0x3 && namesz==4 && descsz==0x1a &&
     194                    ::strcmp((const char*)noteContent+offset+sizeof(Elf64_Nhdr), "AMD")==0)
     195                {    // AMDGPU type
     196                    const uint32_t* content = (const uint32_t*)
     197                            (noteContent+offset+sizeof(Elf64_Nhdr) + 4);
     198                    input->archMinor = ULEV(content[2]);
     199                    input->archStepping = ULEV(content[3]);
     200                }
     201                size_t align = (((namesz+descsz)&3)!=0) ? 4-((namesz+descsz)&3) : 0;
     202                offset += sizeof(Elf64_Nhdr) + namesz + descsz + align;
     203            }
     204        }
     205       
    181206        // if no kernels and data
    182207        if (kernelInfosNum==0)
     
    781806    {
    782807        char buf[40];
    783         size_t size = snprintf(buf, 40, ".driver_version %u\n",
     808        size_t size = snprintf(buf, 40, ".arch_minor %u\n", amdCL2Input->archMinor);
     809        output.write(buf, size);
     810        size = snprintf(buf, 40, ".arch_stepping %u\n", amdCL2Input->archStepping);
     811        output.write(buf, size);
     812        size = snprintf(buf, 40, ".driver_version %u\n",
    784813                   amdCL2Input->driverVersion);
    785814        output.write(buf, size);
  • CLRadeonExtender/trunk/amdbin/AmdCL2BinGen.cpp

    r2419 r2492  
    5656
    5757AmdCL2GPUBinGenerator::AmdCL2GPUBinGenerator(GPUDeviceType deviceType,
     58       uint32_t archMinor, uint32_t archStepping,
    5859       uint32_t driverVersion, size_t globalDataSize, const cxbyte* globalData,
    5960       size_t rwDataSize, const cxbyte* rwData,
     
    6162        : manageable(true), input(nullptr)
    6263{
    63     input = new AmdCL2Input{deviceType, globalDataSize, globalData,
    64                 rwDataSize, rwData, 0, 0, 0, nullptr, false, { }, { },
    65                 driverVersion, "", "", kernelInputs };
     64    input = new AmdCL2Input{deviceType, archMinor, archStepping,
     65                globalDataSize, globalData, rwDataSize, rwData, 0, 0, 0,
     66                nullptr, false, { }, { }, driverVersion, "", "", kernelInputs };
    6667}
    6768
    6869AmdCL2GPUBinGenerator::AmdCL2GPUBinGenerator(GPUDeviceType deviceType,
     70       uint32_t archMinor, uint32_t archStepping,
    6971       uint32_t driverVersion, size_t globalDataSize, const cxbyte* globalData,
    7072       size_t rwDataSize, const cxbyte* rwData,
     
    7274        : manageable(true), input(nullptr)
    7375{
    74     input = new AmdCL2Input{deviceType, globalDataSize, globalData,
    75                 rwDataSize, rwData, 0, 0, 0, nullptr, false, { }, { },
    76                 driverVersion, "", "", std::move(kernelInputs) };
     76    input = new AmdCL2Input{deviceType, archMinor, archStepping,
     77                globalDataSize, globalData, rwDataSize, rwData, 0, 0, 0,
     78                nullptr, false, { }, { }, driverVersion, "", "",
     79                std::move(kernelInputs) };
    7780}
    7881
     
    16381641};
    16391642
     1643static const size_t noteAMDGPUTypeOffset = 0x74;
     1644
    16401645static const cxbyte noteSectionData16_3[200] =
    16411646{
     
    16671672};
    16681673
     1674static const size_t noteAMDGPUTypeOffset_16_3 = 0x48;
     1675
    16691676static CString constructName(size_t prefixSize, const char* prefix, const CString& name,
    16701677                 size_t suffixSize, const char* suffix)
     
    19321939                                  SHT_STRTAB, SHF_STRINGS, 0, 0));
    19331940            innerBinSectionTable[ELFSECTID_STRTAB-ELFSECTID_START] = extraSectionIndex++;
    1934             if (!gpuProDriver)
    1935                 innerBinGen->addRegion(ElfRegion64(sizeof(noteSectionData16_3),
    1936                            noteSectionData16_3, 8, ".note", SHT_NOTE, 0));
    1937             else
    1938             {   /* AMD GPU PRO */
    1939                 noteBuf.reset(new cxbyte[sizeof(noteSectionData16_3)]);
    1940                 ::memcpy(noteBuf.get(), noteSectionData16_3, sizeof(noteSectionData16_3));
     1941           
     1942            noteBuf.reset(new cxbyte[sizeof(noteSectionData16_3)]);
     1943            ::memcpy(noteBuf.get(), noteSectionData16_3, sizeof(noteSectionData16_3));
     1944            // set AMDGPU type
     1945            SULEV(*(uint32_t*)(noteBuf.get()+noteAMDGPUTypeOffset_16_3),
     1946                  (arch==GPUArchitecture::GCN1_2) ? 8 : 7);
     1947            SULEV(*(uint32_t*)(noteBuf.get()+noteAMDGPUTypeOffset_16_3 + 4),
     1948                  input->archMinor);
     1949            SULEV(*(uint32_t*)(noteBuf.get()+noteAMDGPUTypeOffset_16_3 + 8),
     1950                  input->archStepping);
     1951           
     1952            if (gpuProDriver)
    19411953                noteBuf[197] = 't';
    1942                 innerBinGen->addRegion(ElfRegion64(sizeof(noteSectionData16_3),
    1943                            noteBuf.get(), 8, ".note", SHT_NOTE, 0));
    1944             }
     1954            innerBinGen->addRegion(ElfRegion64(sizeof(noteSectionData16_3),
     1955                       noteBuf.get(), 8, ".note", SHT_NOTE, 0));
    19451956            innerBinSectionTable[AMDCL2SECTID_NOTE-ELFSECTID_START] = extraSectionIndex++;
    19461957        }
     
    20082019        if (!is16_3Ver)
    20092020        {   /* this order of section for 1912.05 driver version */
    2010             innerBinGen->addRegion(ElfRegion64(sizeof(noteSectionData), noteSectionData, 8,
    2011                         ".note", SHT_NOTE, 0));
     2021            noteBuf.reset(new cxbyte[sizeof(noteSectionData)]);
     2022            ::memcpy(noteBuf.get(), noteSectionData, sizeof(noteSectionData));
     2023            // set AMDGPU type
     2024            SULEV(*(uint32_t*)(noteBuf.get()+noteAMDGPUTypeOffset),
     2025                  (arch==GPUArchitecture::GCN1_2) ? 8 : 7);
     2026            SULEV(*(uint32_t*)(noteBuf.get()+noteAMDGPUTypeOffset + 4),
     2027                  input->archMinor);
     2028            SULEV(*(uint32_t*)(noteBuf.get()+noteAMDGPUTypeOffset + 8),
     2029                  input->archStepping);
     2030            innerBinGen->addRegion(ElfRegion64(sizeof(noteSectionData),
     2031                       noteBuf.get(), 8, ".note", SHT_NOTE, 0));
     2032           
    20122033            innerBinSectionTable[AMDCL2SECTID_NOTE-ELFSECTID_START] = extraSectionIndex++;
    20132034            innerBinGen->addRegion(ElfRegion64(0, (const cxbyte*)nullptr, 1, ".strtab",
  • CLRadeonExtender/trunk/doc/ClrxAsmAmdCl2.md

    r2365 r2492  
    6060
    6161Set ACL version string.
     62
     63### .arch_minor
     64
     65Syntax: .arch_minor ARCH_MINOR
     66
     67Set architecture minor number.
     68
     69### .arch_stepping
     70
     71Syntax: .arch_minor ARCH_STEPPING
     72
     73Set architecture stepping number.
    6274
    6375### .arg
  • CLRadeonExtender/trunk/tests/amdasm/DisasmDataTest.cpp

    r2381 r2492  
    10861086        R"ffDXD(.amdcl2
    10871087.gpu Bonaire
     1088.arch_minor 0
     1089.arch_stepping 0
    10881090.driver_version 191205
    10891091.compile_options ""
  • CLRadeonExtender/trunk/tests/amdbin/AmdCL2BinGen.cpp

    r2390 r2492  
    502502        amdCL2Input.bssAlignment = innerBin.getBssAlignment();
    503503        amdCL2Input.bssSize = innerBin.getBssSize();
     504       
     505        {
     506            const cxbyte* noteContent = innerBin.getSectionContent(".note");
     507            size_t notesSize = innerBin.getSectionHeader(".note").sh_size;
     508            // find note about AMDGPU
     509            for (size_t offset = 0; offset < notesSize; )
     510            {
     511                const Elf64_Nhdr* nhdr = (const Elf64_Nhdr*)(noteContent + offset);
     512                size_t namesz = ULEV(nhdr->n_namesz);
     513                size_t descsz = ULEV(nhdr->n_descsz);
     514                if (ULEV(nhdr->n_type) == 0x3 && namesz==4 && descsz==0x1a &&
     515                    ::strcmp((const char*)noteContent+offset+sizeof(Elf64_Nhdr), "AMD")==0)
     516                {    // AMDGPU type
     517                    const uint32_t* content = (const uint32_t*)
     518                            (noteContent+offset+sizeof(Elf64_Nhdr) + 4);
     519                    amdCL2Input.archMinor = ULEV(content[2]);
     520                    amdCL2Input.archStepping = ULEV(content[3]);
     521                }
     522                size_t align = (((namesz+descsz)&3)!=0) ? 4-((namesz+descsz)&3) : 0;
     523                offset += sizeof(Elf64_Nhdr) + namesz + descsz + align;
     524            }
     525        }
     526       
    504527        amdCL2Input.samplerConfig = samplerConfig;
    505528        if (samplerConfig)
Note: See TracChangeset for help on using the changeset viewer.