What is a GPU (Graphics Processing Unit)?

GPU (Graphics Processing Unit) is a processor dedicated explicitly to graphics processing to offload the workload of the central processor in applications such as Video Games and interactive 3D applications.

What is the GPU?

Graphics are mostly rendered on the GPU. The CPU can perform other calculations while the GPU implements primitive methods optimized for graphics rendering.

For example, anti-aliasing is used in 3D graphics. This makes shapes appear more realistic.

There are also primitives for drawing rectangles, triangles, circles, and arcs. GPUs today offer more realistic effects.

Historical

Modern GPUs are descendants of the monolithic graphics chips of the 1970s and 1980s. These chips had limited BitBLT support in the form of sprites. They also generally lacked support for drawing graphics and shapes.

Some GPUs could perform various operations on the display list. This used DMA to reduce host computer overhead. The Atari 800 and 5200 were early examples of this. Atari used the ANTIC coprocessor.

In the late 1980s and early 1990s, high-speed microprocessors were popular. These microprocessors were suitable for running the most advanced GPUs.

Many graphics cards for PCs and workstations used DSPs. For example, the Texas Instruments TMS340 series implemented fast drawing functions. Laser printers also incorporated dedicated GPU enclosures on the AMD 29000 RISC processor.

As semiconductor technology advanced, drawing and BitBLT functions were moved onto the same chip. For example, they were integrated on the same board as the frame buffer controller, like VGA.

These thin 2D accelerators were not as flexible as microprocessor-based ones. However, they were easier to manufacture and sell.

The Commodore AMIGA was the first mass-produced computer to include a blitter unit. The IBM 8514 graphics system was also one of the first PC video cards to implement 2D primitives in hardware.

What’s the Difference Between CPU and GPU?

It’s not possible to replace a CPU with a GPU. However, GPUs today are very powerful. Some GPUs can even surpass older CPUs.

GPU power comes from two factors. The first is the GPU’s high specialization, as it’s designed for single-tasking.

This allows for more efficient task execution. For example, GPUs are optimized for floating-point computations in 3D graphics.

On the other hand, graphics applications are highly parallelized because the underlying computational units are completely independent.

Therefore, it’s strategic to load more work onto GPUs. Current GPUs have half a dozen vertex processors.

They also have two to three times the number of pixel processors. This translates to lower clock speeds and higher power through parallel processing.

The architectural difference between a CPU and a GPU is significant. A CPU has a Von Neumann architecture, but a GPU is based on the Circulation Model.

This model facilitates parallel processing and also provides greater segmentation for GPU tasks.

What is GPU Architecture?

A GPU is divided into several functional units. These units are the vertex and pixel processors. Thus, the vertex and pixel are the main units.

In addition, the ROP is the most important. It is fast and stores intermediate results.

Initially, the GPU receives vertex information from the CPU. These vertices are processed in the vertex shader. This is where shape transformations or motions are performed. Then, the vertices are clipped and rasterized. These stages do not place a significant load on the GPU.

The main bottleneck is the pixel shader. This is where textures and other pixel transformations are applied. Effects such as antialiasing, blending, and fog are added.

The ROP works to prepare the pixels and apply effects. The output is then sent to the framebuffer.

The pixels can then be displayed on a digital monitor. Or, an analog signal is generated for an analog monitor. In the latter case, it is passed through the DAC and displayed on the screen.

Programming

Initially, GPU programming was done using BIOS interrupt calls. Later, GPU programming occurred in assembly language specific to each model.

Later, APIs were developed, providing a more uniform language. The first widespread API was OpenGL. This led to the emergence of Microsoft DirectX.

After API development, a high-level language was decided upon. This created a language for graphics that was more user-friendly.

OpenGL and DirectX supported these offerings. The high-level standard language, GLSL, is implemented along with the OpenGL library.

The Californian company NVIDIA created a proprietary language called Cg. Cg provided better performance than GLSL. Microsoft also developed HLSL to be compatible with Cg.