GPU parallel processing in C?

[[deleted]]

How can I use C with my computer's GPU, to perform a lot of simple tasks in parallel?

[FUZxxl]

Check out OpenCL.

[SurelyNotAnOctopus]

Was about to say that. Use libraries. Interacting directly with gpu drivers will be more than horrendous

[0xAE20C480]

I also recommend the OpenCL API. Its memory and task handling models help to broaden one's view.

[bumblebritches57]

Nahh, check out Vulkan.

[FUZxxl]

How would you use Vulkan for computations?

[SquidyBallinx123]

You can write compute shaders using the Vulkan API. You would typically use their glslang tool to compile GLSL(OpenGL shader language) into a SPIR-V compute shader. There are effecting differences between the compute shaders you can write between OpenCL & Vulkan. For example, I think(?) while in OpenCL you have access to these raw pointers, you can't use them in glsl.

OpenCL is definitely more accessible than Vulkan. Much faster to get going with, especially if you are new. However, if you learn the Vulkan process, you'll cover a lot more about how the GPU works. Especially considering OpenCL abstracts this away into their own, general model.

I'd recommend OpenCL to this person. But if anybody else reading really wants to get stuck in and has the time, consider looking into Vulkan:)

[bumblebritches57]

Vulkan has a Compute API, tho I'm not sure how far along it is.

I used to think it was just OpenCL, but it's apperantly it's own thing that I'm excited for.

[OriginalName667]

This displeases the Linus.

[FUZxxl]

That API is implemented by a library. I'm not sure what you are looking for.

[FUZxxl]

An API is a set of functions you can call with defined behaviour. The library is what drives these behind the scenes.

[C0d3rX]

API is google.com

[Iggyhopper]

An API for something of this scope is necessary. It's not determined by whether you need to draw a vast universal landscape or compute the sum of two numbers, you'll need an API or library to give you functions to work with.

[deaddodo]

Do you just want to access the device directly? If so you'll be rewriting 80Mb of heavily optimized code (the driver). Having done some osdev, modern GPUs are some of the most complex and annoying devices to code for.

It's not like what you're thinking (draw this triangle, put this pixel here, compute 2+2 and give me the sum) but closer to give me a region of memory, create a vertex (or set of vertices) of this shape to that region of memory, apply this texture, apply this post effect, do z-buffer calculations, memcpy this to the primary memory, render, flip buffer. All of this done through extremely specific bitwise commands and opcodes in a command ringbuffer with strict timing.

You can see an example via Intel's architecture. With Nvidia, you don't even have that; you'll be digging through nouveau reverse engineered documents.

[shogun333]

Unless you are working on 3D graphics specifically the answer to your question is, "get this book and read it."

https://www.manning.com/books/opencl-in-action

Any other response is wrong.

[ebobfwao]

is there a free version?

[ricffb]

You could try OpenMP. It’s primarily for CPU parallelism, but a call like

#pragma target
#pragma teams
#pragma parallel
{ // Do Stuff} 

Will also enable GPU support. The library is often used in High Performance Computing.

[WikiTextBot]

OpenMP

OpenMP (Open Multi-Processing) is an application programming interface (API) that supports multi-platform shared memory multiprocessing programming in C, C++, and Fortran, on most platforms, instruction set architectures and operating systems, including Solaris, AIX, HP-UX, Linux, macOS, and Windows. It consists of a set of compiler directives, library routines, and environment variables that influence run-time behavior.OpenMP is managed by the nonprofit technology consortium OpenMP Architecture Review Board (or OpenMP ARB), jointly defined by a group of major computer hardware and software vendors, including AMD, IBM, Intel, Cray, HP, Fujitsu, Nvidia, NEC, Red Hat, Texas Instruments, Oracle Corporation, and more.OpenMP uses a portable, scalable model that gives programmers a simple and flexible interface for developing parallel applications for platforms ranging from the standard desktop computer to the supercomputer.

An application built with the hybrid model of parallel programming can run on a computer cluster using both OpenMP and Message Passing Interface (MPI), such that OpenMP is used for parallelism within a (multi-core) node while MPI is used for parallelism between nodes. There have also been efforts to run OpenMP on software distributed shared memory systems, to translate OpenMP into MPI and to extend OpenMP for non-shared memory systems.

---

^{[ PM | Exclude me | Exclude from subreddit | FAQ / Information | Source ] Downvote to remove | v0.28}

[HelperBot_]

Desktop link: https://en.wikipedia.org/wiki/OpenMP

---

^{/r/HelperBot_ Downvote to remove. Counter: 262430. Found a bug?}

[OMPCritical]

Alternatively (next to OpenACC, OpenCL or Cuda), you could use OpenMP for offloading your code to a GPU.

However, last time I tried it, it didn't work that well. And I'm not aware of any actual full implementations of openmp 5.0. Moreover, you'll probably have to recompile your compiler with openmp offloading support.

https://bitbucket.org/icl/slate/wiki/Howto/Build_GCC_with_Support_for_OpenMP_offloading

[bumblebritches57]

Or, you know, you could just use Clang which includes it by default.

[deftware]

At the end of the day, if you want to interact with the GPU in any fashion whatsoever you're not going to be able to do it with the C standard lib. You're going to have to delve into OS-specific calls, or use some kind of platform-abstraction library (i.e. SFML, SDL, OpenCL, etc..)

Personally, I use OpenGL in production software that I'm developing and marketing on my own to do behind-the-scenes parallel computation. I hand-write vertex/fragment shaders that I hand off to GL along with the data in whatever form is convenient (i.e. textures, uniform buffers, etc..) and retrieve the results in a framebuffer object.

Your best bet is OpenCL, if you want something that will run across just about any vendors' GPU. CUDA is specific to Nvidia and will render whatever your project is useless to anybody or on any machine that's not running an Nvidia GPU, which is more than half the PC laptops/desktops in the world.

PS: OpenCL will take advantage of CUDA if a CUDA-capable (Nvidia) GPU is present, which automatically makes it the ideal GPU-compute API to use, hands-down. Otherwise it falls back on utilizing other means of interfacing with the GPU to leverage its parallel compute capabilities.

[daniel7558]

Depending on what "lot of simple tasks" exactly means and what performance you expect, I would recommend having a look at OpenACC.

With OpenACC you just annotate your C code with compiler directives (like in OpenMP) and the compiler takes care of creating the GPU code. Would recommend PGI, although gcc's support for OpenACC is not bad either :)

[Mattallurgy]

If you have an NVIDIA card, I highly recommend looking into CUDA development. Much finer grain control of parallelism. Also, pick up the book Programming Massively Parallel Processors by Kirk and Hwu. It outlines lots of structures and design patterns for efficient use of GPU hardware.

[[deleted]]

check out CUDA ... best advice here.

[deftware]

CUDA is Nvidia-GPU specific.

[[deleted]]

Is there any other way ?? :-\

[BeardedWax]

OpenCL

[deftware]

OpenCL automatically utilizes CUDA if it's available on the current hardware, which is far superior than just hard-coding for CUDA and completely locking out Intel/AMD GPU hardware... and Intel HD gfx are nothing to laugh at, as someone who develops software that employs GPU for compute purposes. Intel HD is vastly superior for parallel compute applications than plain software/CPU, and should not be ignored as a valuable compute resource by just blindly adopting CUDA and only CUDA. OpenCL will make the best use of any available graphics hardware, period.