cutlass VS Open3D

I would recommend the course from Oxford (https://people.maths.ox.ac.uk/gilesm/cuda/). Also explore the tutorial section of cutlass (https://github.com/NVIDIA/cutlass/blob/main/media/docs/cute/...) if you want to learn more about high performance gemm.

The latter (and I guess you were asking about this one) is designed to accelerate NN inference in reduced precision. It is possible to use Tensor Cores for you own purposes, mainly through CUTLASS. But because Tensor Cores are designed to execute matrix multiplications, it can be hard to adapt your problem to them. The performance with them is insane (IIRC 32x the performance of the INT32 pipeline), but only for matrix multiplication…

If you want to learn about controlling Tensor Cores, the main way is through the CUTLASS library, that wraps the complexity of Tensor Cores into higher level abstractions. You can also look for mma/wmma instructions in the PTX specification, or for the WMMA API in CUDA.

> we used tensor cores and managed to get back fp32 accuracy with 3 rounds of the things

Hey are you referring to 3xTF32 (https://github.com/NVIDIA/cutlass/tree/master/examples/28_am...)? IMO this is a perfect example where proper abstraction could save engineers non-trivial amount of time - imagine a compiler stack which allows 3xTF32 as a normal dtype and subsequent analysis compatible with this special dtype :-)

This is a great post for people who are new to optimizing GPU code.

It is interesting to see that the author got this far without interchanging the innermost loop over k to the outermost loop, as is done in CUTLASS (https://github.com/NVIDIA/cutlass).

As you can see in this blog post the code ends up with a lot of compile-time constants (e.g. BLOCKSIZE, BM, BN, BK, TM, TN) one way to optimize this code further is to use an auto-tuner to find the optimal value for all of these parameters for your GPU and problem size, for example Kernel Tuner (https://github.com/KernelTuner/kernel_tuner)

Some examples here have a benchmark: https://github.com/NVIDIA/cutlass/blob/master/examples/24_gemm_grouped/gemm_grouped.cu

I would like to make a minimum CMakeLists to use the CUDA CUTLASS library in another project. The build system is CMake, however I have little experience with CMake.

If you already know some C++, the Nvidia devblog is a great resource. Going further, Cub and Cutlass provide examples of efficient implementations for key operations at all hardware levels. Finally, this is more anecdotal but I always start my lectures on Cuda programming with the pictures in this doc page, to provide some intuition on the different memory layers that you can leverage to speed up a program. In any case, good luck :-)

I was going to file a bug about another issue, but I have to download the development version. This is why I want this solved quickly. None of the links seem to work: https://github.com/isl-org/Open3D/issues/6259

Open3D (JSON, LOG, PLY) 1

There's also Open3D (O3D) the point cloud library... http://www.open3d.org/

would this help?

http://www.open3d.org/ seems like a good choice. Is there anything better I'm missing?

Open3D v0.13.0 http://www.open3d.org/

Sweet work! If you are interested in 3D reconstruction, have a look at http://www.open3d.org.

I normally use Open3D (http://www.open3d.org/) for point cloud visualization, which besides free view also provides an interface for rendering. For the rotation effect, place your object in the world origin, and the camera at a fixed world position looking towards the object. For every desired angle, rotate your object around the required axis by that angle and render the view. Then combine to a gif or video for presentations.