2 ms·
> I feel like AMD for some reason doesn't understand that support for GPGPU on the consumer stack is important to eventually getting adoption in the enterprise
by roenxi 4y ago
> I feel like AMD for some reason doesn't understand that support for GPGPU on the consumer stack is important to eventually getting adoption in the enterprise space.
I made an attempt a few years ago at getting in to the machine learning world and discovered very quickly that I was facing a choice - either I could go AMD and open source drivers or Nvidia and cutting edge software. To learn the algorithms on my own PC just didn't seem feasible with an AMD GPU - running them on the CPU was too slow and I never found a way to make things work on the GPU with the resources I located. I gave up on AI since open source software is more important to me.
Maybe I just lacked the right mindset, but the difficulties were so extreme it seems plausible that most people with an AMD GPU never learned to use ROCm at the amateur level and there wasn't a sufficiently good strategy to get it adopted at the professional level without an amateur community.
Low level GPU programming is really hard. OpenGL, CUDA, OpenCL, whatever. I'm still on the lookout for an introductory resource on how I'm meant to use an AMD gpu to multiple 2 matrices together. I literally can't find one with a 5 minute google search, I get a blank article [0]. Maybe it is just blank for me? For using OpenGL I can just go play around [1]. There needs to be a strong community of advanced people explaining what to do which means big amateur support.
So, in short, I strongly agree. I think AMDs (poor) support of consumer stack for GPGPU hurt them a lot more than they realise. OpenCL doesn't seem to cut it. The lack of libraries and community indicates that the feeder pipeline of amateur -> professional growth is broken and nobody is learning to use their platform even for fun.
[0] https://developer.amd.com/article/a-heterogeneous-accelerated-matrix-multiplication-opencl-apu-gpu-fast-matrix-multiply/ https://developer.amd.com/article/a-heterogeneous-accelerate...
[1] https://www.shadertoy.com/ https://www.shadertoy.com/
- heavyset_go 4y agoROCm is a mess and I am similarly disappointed in AMD for the same reasons. Using AMD GPUs for accelerated compute on Linux is buggy and disappointing even if you get close to making it work.
- touisteur 4y agoMoreover they screwed over a big chunk of the people willing to use their hardware and their OpenCL stack (who might have migrated to ROCm if there was a not too painful path) when they EoLed their embedded GPU offer out of the blue. Now your options are TigerLake (and who knows whether Intel is going to keep the sycl/oneAPI support up, and I don't feel Intel really serious about GPUs in the long term... Or even in the 'open standard' shtick they're selling on oneAPI/SYCL) or NVIDIA and the CUDA collar.
- paulmd 4y agoPyTorch would probably be the easiest way to get started there, it should give you a NumPy style handle into high-level objects. As far as low-level, OpenCL has always had a horrendous amount of boilerplate just to get started, CUDA is a little better. One thing that can help is Thrust framework on CUDA, which attempts to provide a C++ STL-style interface to GPU operations. I am not saying it's super performant but especially it can give you a place to start and handle some of the boilerplate automatically. In classic AMD fashion there is a me-too copy that hasn't been updated in like 5+ years, probably was some intern's summer project or some employee's resume-driven-development thing and AMD has just always left this trail of abandoned projects in their wake. https://thrust.github.io/ https://thrust.github.io/ https://hsa-libraries.github.io/Bolt/html/ https://hsa-libraries.github.io/Bolt/html/ But basically what this is going to look like is a main function that sets everything up, and then a __global__ kernel launch that does the actual computation. You probably will have a 1D or 2D grid of threads, where each thread gets a threadIdx.x and threadIdx.y and that determines the row/column of elements they compute. For Thrust/Bolt you can do a cheat implementation by zipping the thread position into a (int x, int y) pair driven by count_iterators, and then having a functor which takes the (x,y) and does the computation. Or the "true" implementation would be an accumulate-reduce operation I guess, but, frankly the STL-style stuff starts to fall apart pretty quickly and it just ends up being a convenient way to hook up the lower-level code without having to worry about too much boilerplate.
- roenxi 4y ago> PyTorch would probably... Less obvious than you might believe. I suspect PyTorch doesn't support any AMD GPU that are more than ~5 years old, because PyTorch is currently ROCm 5.0 and that only supports Vega 2.0 and up [0]. This is that thing about AMD not doing a great job of supporting consumer GPU. There was a window where PyTorch allegedly supported ROCm 4.x and therefore my GPU, but I expect that was a misdirection since AMD never seemed to make this stuff work. [0] https://docs.amd.com/bundle/ROCm-Release-Notes-v5.2/page/About_This_Document.html https://docs.amd.com/bundle/ROCm-Release-Notes-v5.2/page/Abo...
- paulmd 4y ago