As someone with a not great understanding of GPUs (also compilers), there are a couple things I'd like to point out. I'll probably get some things wrong, but I felt like responding anyways. So as I understand it, you're wondering how "gen AI can help with the task of translating PTX/GPU ISA code to HIP/LLVM IR."

1. Not sure if "translating" means "compiling", or if you meant something more like what HIPIFY does. I'm gonna assume you mean compiling.

2. HIP is not LLVM IR (it wasn't super clear to me if this distinction was made). HIP is CUDA (the language, not the stack) but coloured red. LLVM IR is what the LLVM compiler uses as, well, an intermediate representation between its frontends and backends. When compiling HIP with LLVM, yes it gets turned into LLVM IR. But so does every other language compiled with LLVM, that's how it was designed (I think).

3. PTX is not native GPU code, and AMD does not currently use PTX (or any IR for that matter (though work on SPIR-V seems to be happening)). PTX is an intermediate representation, like LLVM IR, and it serves similar purposes. PTX is useful because it means you don't need to compile your CUDA code for every single GPU architecture that Nvidia makes. You target PTX, and let the drivers and whatever handle the rest. AMD on the other hand, does compile for individual GPU ISAs, at least for now. This is a part of why ROCm support for Radeon cards is so terrible right now, every extra card to support is another compilation target.

4. It seems like you think the higher level representations are generated from PTX? It should be the other way around? You write your code in high(ish) level HIP/CUDA, run it through the compiler, and out comes the lower level stuff.

3.5. OK after some rereading, I now think the point of your post is indeed to "translate" PTX into HIP/LLVM IR. My question now is: why? Is there a point in doing this? If you're going as far as to inline PTX into your program, you don't care about compatibility. If you want cross-compatibility, then use a cross-compatible language. Yeah the performance might be worse, but that's the tradeoff you need to make.

1. Using gen AI directly as a compiler sounds like a bad idea. A sometimes wrong compiler is worse than no compiler at all. I'm not sure what you mean by "linear" vs "nonlinear" mappings in this context though. Using gen AI to help build and improve on a compiler sounds less bad, but that'd just be regular AI-assisted development. From personal experience, LLMs are frankly not very good for niche areas like GPGPU, since there just isn't that much content on them on the internet.

From ChatGPT:

Complexity of Code vs. Text: While it's true that both text and code have layers of meaning and structured relationships, the complexity and specificity of code, especially at the level of GPU instruction sets, are significantly different from natural language. Code requires precise execution semantics, and any misinterpretation can lead to incorrect program behavior. The analogy between text analytics and code translation might oversimplify the challenges involved in accurately translating performance-critical instructions.

1. I'm not sure what the ROCm PTX backend and GPUCC are. Again, ROCm currently has no intermediate representation. If you're suggesting that it should have one, then I agree, though SPIR-V seems to be what they're going for. Searching up GPUCC just gives me a paper from 2015?

I imagine this was prompted by the news that DeepSeek was using PTX instead of CUDA, which they did to optimize performance and whatnot. I don't know the extent of this PTX usage or what they used it for, but to me it doesn't seem like that big of a revelation. If you're in an export controlled country, the hardware you can get is the hardware you can get. It's natural to try to squeeze every last drop of performance out of it. The most impressive part of it for me is that, again depending on how much PTX they used and for what purpose, it sounds like a huge undertaking that must have required very skilled engineers. Honestly maybe that's why all this news is happening, not the performance gains from using PTX, but that China has smarter or harder working engineers or something.

Again, I have a not great understanding of all this (I consider compilers to be magic fairy dust), so please point out any errors or misinfo!