This looks like the language I've wanted for a long time. I'm excited to see how this plays out.
Bend: a high-level language that runs on GPUs (via HVM2)
141–150 of 269 posts
Re: Bend: a high-level language that runs on GPUs (via HVM2)
#142This is very exciting. I don’t have any GPU background, but I have been worrying a lot about CUDA cementating itself in the ecosystem. Here devs don’t need CUDA directly which would help decoupling the ecosystem from cynical mega corps, always good! Anyway enough politics.. Tried to see what the language is like beyond hello world and found the guide[1]. It looks like a Python and quacks like a Haskell? For instance,…
We have a replacement for CUDA, it is called C++17 parallel algorithms. It has vendor support for running on the GPU by Intel, AMD and NVIDIA and will also run on all your cores on the CPU. It uses the GPU vendors compiler to convert your C++ to something that can natively run on the GPU. With unified memory support, it becomes very fast to run computations on heap allocated memory using the GPU, but implementations also support non-unified memory
Vendor support:
- https://www.intel.com/content/www/us/en/developer/articles/g...
- https://rocm.blogs.amd.com/software-tools-optimization/hipst...
- https://docs.nvidia.com/hpc-sdk/archive/20.7/pdf/hpc207c++_p...
Re: Bend: a high-level language that runs on GPUs (via HVM2)
#143Massive promises of amazing performance but they can't find one convincing example to showcase. It's hard to see what they're bringing to the table when even the simplest possible Haskell code just as fast on my 4 year old laptop with an ancient version of GHC (8.8). No need for an RTX 4090. module Main where sum' :: Int -> Int -> Int sum' 0 x = x sum' depth x = sum' (depth - 1) ((x \* 2) + 0) + sum' (depth - 1) ((x…
You're wrong. The Haskell code is compiled to a loop, which we didn't optimize for yet. I've edited the README to use the Bitonic Sort instead, on which allocations are unavoidable. Past N=20, HVM2 performs 4x faster than GHC -O2.
What? I ran your example, from your readme, where you promise a massive performance improvement, and you're accusing me of doing something wrong?
This is exactly what a scammer would say.
I guess that's the point here. Scam people who don't know anything about parallel computing by never comparing against any other method?
Re: Bend: a high-level language that runs on GPUs (via HVM2)
#144Earlier quoted context omitted.
The only claim I made is that it scales linearly with cores. Nothing else! The other link on the front page says: "Welcome to the Parallel Future of Computation"
Scaling with cores is synonym of parallel.
"Future" has some mild speed implications but it sounds like you're doing reasonably there, bug nonwithstanding.
Re: Bend: a high-level language that runs on GPUs (via HVM2)
#145Earlier quoted context omitted.
Right below install instructions, on Bend's README.md: > But keep in mind our code gen is still on its infancy, and is nowhere as mature as SOTA compilers like GCC and GHC. Second paragraph of Bend's GUIDE.md: > While cool, Bend is far from perfect. In absolute terms it is still not so fast. Compared to SOTA compilers like GCC or GHC, our code gen is still embarrassingly bad, and there is a lot to improve. That said,…
> Right below install instructions Yeah exactly. I read most of the readme and watched the demo, but I'm not interested in installing it so I missed this. I would recommend moving this to the first section in its own paragraph. I understand you might not want to focus on this but it's important information and not a bad thing at all.
That's a great feedback actually, thank you.
We'll add the disclaimer before the install instructions instead!
Re: Bend: a high-level language that runs on GPUs (via HVM2)
#146For what it's worth, I ported the sum example to pure python. def sum(depth, x): if depth == 0: return x else: fst = sum(depth-1, x*2+0) # adds the fst half snd = sum(depth-1, x*2+1) # adds the snd half return fst + snd print(sum(30, 0)) under pypy3 it executes in 0m4.478s, single threaded. Under python 3.12, it executed in 1m42.148s, again single threaded. I mention that because you include benchmark information: CP…
I have no dog in this fight, but feel compelled to defend the authors here. Recursion does not test compute, rather it tests the compiler's/interpreter's efficiency at standing up and tearing down the call stack. Clearly this language is positioned at using the gpu for compute-heavy applications and it's still in its early stages. Recursion is not the target application and should not be a relevant benchmark.
[flagged]
Re: Bend: a high-level language that runs on GPUs (via HVM2)
#147This is awesome and much needed. Keep going, forget the overly pedantic folks, the vision is great and early results are exciting.
Re: Bend: a high-level language that runs on GPUs (via HVM2)
#148Earlier quoted context omitted.
I have no dog in this fight, but feel compelled to defend the authors here. Recursion does not test compute, rather it tests the compiler's/interpreter's efficiency at standing up and tearing down the call stack. Clearly this language is positioned at using the gpu for compute-heavy applications and it's still in its early stages. Recursion is not the target application and should not be a relevant benchmark.
[flagged]
Where did he claim it is fast? As far as I can see the only claim is that it scales linearly with cores. Which it actually seems to do.
Re: Bend: a high-level language that runs on GPUs (via HVM2)
#149Earlier quoted context omitted.
That's how development under open source works. You can't please everyone.
There’s a big difference between developing something and announcing loudly that you have something cool; the developers have done the latter here.
Dude we're running unrestricted recursion and closures on GPUs! If that's not cool to you, I apologize, but that mind-blowingly cool to me, and I wanted to share it, even though the codegen is still initial. Hell I was actually going to publish it with the interpreters only, but I still coded an initial compiler because I thought people would like to see where it could go :(
Re: Bend: a high-level language that runs on GPUs (via HVM2)
#150Earlier quoted context omitted.
We will have 64-bit boxed numbers really soon! As in, next month, or earlier if users find this to be a higher priority.
What other types are you planning? Maybe some floats (even if only on cpu targets, would be nice).
Immutable textures and strings. Perhaps actual mutable arrays. Many numeric types like F64, U64, I64. And some vector types like F16x4.