P024 | NVIDIA Empire and the Next Computing Civilization | GPGPU - Turning GPUs into General-Purpose Computers

The GPU was originally built to draw images.

Its job was to receive vertex data, transform geometric information, process pixels, and produce a final image. By applying similar mathematical operations across large amounts of visual data in parallel, the GPU could render increasingly complex three-dimensional scenes.

Then researchers and engineers recognized something more important.

The GPU was not merely drawing. It was performing large numbers of numerical operations at the same time.

If non-graphical data could be presented in a form the graphics pipeline understood, perhaps the same hardware could be used for scientific computing, simulation, and other numerical workloads.

That shift in thinking became GPGPU: general-purpose computing on graphics processing units.

A Parallel Computer Hidden Inside a Drawing Device

The conventional graphics pipeline begins with vertex data. Programmable shaders transform that data, pixel operations construct the image, and the result appears on the screen.

Shaders were designed to calculate visual effects such as lighting, color, texture, and geometry. Once shaders became programmable, however, developers could change the mathematical work being performed.

The graphics processor still appeared to be rendering an image, but the instructions inside the pipeline could represent something else.

Behind the drawing device was a massively parallel numerical machine.

GPGPU emerged when developers began treating that machine as a computing resource rather than only a graphics component.

Turning Numbers into Images

Early GPGPU techniques required an unusual workflow.

First, developers encoded general numerical data as images or textures. Next, they mapped the desired calculations onto shader programs. The GPU processed the data through its graphics pipeline, and the resulting pixels were read back and interpreted as numerical results.

The sequence looked like this:

1. Input computational data as an image or texture
2. Map the calculation onto programmable shaders
3. Execute many operations in parallel
4. Read the output pixels back as results

A matrix of scientific values could be represented as a grid of pixels. A shader operation intended for color or lighting could be rewritten to perform mathematical transformations on those values.

From the GPU’s point of view, it was processing graphics.

From the developer’s point of view, it was solving a scientific or engineering problem.

This was an ingenious reuse of an existing architecture.

From Graphics to Science and Simulation

Many non-graphical workloads share the same structural characteristics as image processing.

They apply similar operations across large datasets. They contain many calculations that can be executed independently. They value high throughput more than the rapid completion of a single sequential instruction stream.

Scientific computing, matrix operations, physical simulation, image analysis, and some financial calculations could therefore benefit from GPU parallelism.

The GPU began moving from a device that created pictures to a device that calculated large numerical systems.

The key innovation was not a completely new processor. It was a new interpretation of a processor that already existed.

Still Bound by Graphics Conventions

Early GPGPU was powerful, but it was not easy to use.

Developers who wanted to perform scientific calculations still had to think in terms of textures, vertices, pixels, frame buffers, and shader programs. Data had to be reformatted for the graphics pipeline, calculations had to fit graphics-oriented rules, and results had to be read back from graphical outputs.

The range of workloads expanded, but general-purpose computation remained bound by graphics conventions.

This created several practical limits.

Programming required specialized knowledge. Data conversion and transfer added overhead. Algorithms that did not fit the graphics pipeline were difficult to express. The available hardware performance was impressive, but the path to using it was narrow.

The problem was no longer whether the GPU could calculate.

The problem was how to make that computational power accessible.

The Beginning of a New Computing Device

GPGPU revealed a broader principle: hardware can become more valuable when its original purpose is reinterpreted.

The parallel machinery developed for graphics could also serve science, engineering, simulation, and eventually artificial intelligence. The GPU’s future was hidden inside capabilities that had already been built for another market.

GPGPU started the transition from drawing device to computing device.

But the transformation was not complete. Developers still needed a programming model that would free GPU computing from the language and conventions of graphics.

That next step would open the processor to a much larger community.

Next: The Arrival of CUDA - Opening Up Compute Resources

#NVIDIAEmpire #NVIDIA #GPU #GPGPU #ParallelComputing #ScientificComputing #Simulation #CUDA