NVIDIA Tesla P40

NVIDIA Tesla P40
NVIDIA Tesla P40 graphics card review

NVIDIA Tesla P40: Why Run LLMs on a 2016 Graphics Card?

The NVIDIA Tesla P40 was introduced in 2016 as a server accelerator for neural networks. Ten years later, it is attracting attention because of its 24 GB of video memory. That is enough to run some language models with 30-32 billion parameters, which do not fit into the video memory of most inexpensive gaming GPUs.

However, the Pascal architecture places significant limits on performance. The Tesla P40 has no Tensor Cores, FP16 computations are slow, and its passive cooling requires modification when the card is installed in a regular computer. How useful is its 24 GB in 2026?

24 GB of Memory on the Pascal Architecture

The Tesla P40 is built around the GP102 chip, related to the GeForce GTX 1080 Ti. It has 3840 CUDA cores, and the GPU clock speed ranges from 1303 to 1531 MHz. The card is equipped with GDDR5 memory on a 384-bit bus, with a bandwidth of 346 GB/s.

Unlike the Tesla P100, which uses the GP100 chip and HBM2 memory, the P40 was primarily designed for neural network inference. Its FP16 performance is approximately 0.19 TFLOPS-about 64 times lower than its FP32 performance.

Graphics card Memory Memory bandwidth FP16 Tensor Cores
NVIDIA Tesla P40 24 GB GDDR5 346 GB/s ~0.19 TFLOPS No
NVIDIA Tesla P100 PCIe 16 GB HBM2 732 GB/s 18.7 TFLOPS No
NVIDIA Tesla V100 PCIe 32 GB HBM2 900 GB/s ~28 TFLOPS 640

NVIDIA specified up to 12 TFLOPS in FP32 and 47 TOPS in INT8 for the P40. However, these figures cannot be directly translated into the speed of modern LLMs. The result depends on the model format, the computational operations used, and software optimization.

Performance in llama.cpp Tests

Text-generation tests are the most representative for the Tesla P40. The results below were obtained in llama.cpp using the Llama 2 7B model with Q4_0 quantization.

Graphics card Memory Prompt processing, tok/s Generation, tok/s
NVIDIA Tesla P40 24 GB 1007 54.7
NVIDIA Tesla P100 16 GB 761 58.4
NVIDIA Tesla V100 32 GB 3043 129.1
NVIDIA GeForce RTX 3060 12 GB 2138 75.6
NVIDIA GeForce RTX 3090 24 GB 5175 158.2

llama-bench test: processing 512 input tokens (pp512) and generating 128 tokens (tg128), using CUDA without Flash Attention. The results were obtained on different systems and llama.cpp versions, so the comparison is approximate.

When generating text, the Tesla P40 falls only slightly behind the P100, despite having substantially lower memory bandwidth. The RTX 3060 is approximately 38% faster, while the RTX 3090 is nearly three times as fast.

The difference is greater when processing the input prompt: the RTX 3090 is more than five times faster than the P40. This is particularly noticeable when working with long documents, when thousands of input tokens must be processed before a response can be generated.

However, Llama 2 7B fits even into 8 GB of video memory. This test demonstrates GPU speed but does not reveal the P40’s main advantage-the ability to run larger models.

Which LLMs Fit into 24 GB

A good example is Qwen2.5-32B-Instruct. In the GGUF format with Q4_K_M quantization, the model weights occupy approximately 19.9 GB. The Tesla P40 has enough space left for the KV cache and computational buffers, although the available context length depends on the launch settings.

This model will not fit entirely on an RTX 3060 with 12 GB. More aggressive quantization will be required, or part of the computation will have to be offloaded to system memory.

The Tesla P40’s capabilities depend on the model’s size and format:

  • 7B-8B: Enough memory for Q4, Q8, and a relatively long context.
  • 14B: Many models fit even in Q8_0, leaving memory for auxiliary data.
  • 30B-32B: Q4 is possible with an appropriate KV-cache size and sufficient space for other buffers.

Capacity should not be confused with performance. A model with 32 billion parameters requires significantly more computation than Llama 2 7B. The results above cannot be used to estimate its speed without separate testing.

For local execution of quantized GGUF models, llama.cpp can be used with a compatible CUDA backend. The P40’s limitations become more noticeable when processing large documents frequently or serving multiple users simultaneously.

Installing It in a Regular Computer

The Tesla P40 is designed for servers with forced-air cooling. The card has no built-in fan, and its maximum power consumption reaches 250 W.

The following factors must be taken into account during installation:

  • Cooling. Directed airflow through the heatsink is required, usually provided by a separate fan and duct.
  • Power. The card uses a server CPU/EPS 8-pin connector. A standard PCIe 8-pin cable must not be connected directly in its place.
  • Video outputs. HDMI and DisplayPort are absent. A monitor will have to be connected to another graphics adapter.
  • Dimensions. The board is approximately 267 mm long and occupies two slots.

Another limitation concerns software support. The Tesla P40 has Compute Capability 6.1. With CUDA Toolkit 13.0, NVIDIA discontinued support for compiling applications for Pascal.

Building software for this architecture requires CUDA Toolkit 12.9 or an earlier compatible version. The latest NVIDIA driver branch supporting Pascal is R580, whose maintenance is scheduled to continue until June 2028.

This does not mean that the P40 will stop working after that date. However, newer versions of computational libraries may require more modern GPUs, so software compatibility must be checked separately.

Is the Tesla P40 Worth Using in 2026?

The Tesla P40 retains practical value because of its 24 GB of memory. It can run quantized LLMs that do not fit on an RTX 3060 with 12 GB or a Tesla P100 with 16 GB. At the same time, both of those cards may be faster in tasks that do not require a large amount of video memory.

The RTX 3090, with the same 24 GB, significantly outperforms the P40 in both generation speed and prompt processing. The Tesla V100 is also substantially faster, but the 16 GB version limits the choice of large models, while the 32 GB version solves this problem.

When choosing a P40, the cost of the card itself is not the only factor to consider. Additional cooling, suitable power delivery, power consumption of up to 250 W, and the need to use a compatible software stack all increase operating costs.

The Tesla P40 makes sense if local LLMs specifically require 24 GB of memory, high speed is not essential, and the cost of a complete system is significantly lower than the alternatives. For a new workstation intended for long-term use, a more modern GPU is preferable.

GPU Comparison

Compare Tesla P40 with other GPUs

Please select GPU from the dropdown list.

Basic

Label Name
NVIDIA
Platform
Professional
Launch Date
September 2016
Model Name
Tesla P40
Generation
Tesla Pascal
Base Clock
1303MHz
Boost Clock
1531MHz
Bus Interface
PCIe 3.0 x16
Transistors
11,800 million
TMUs
Texture Mapping Units (TMUs) serve as components of the GPU, which are capable of rotating, scaling, and distorting binary images, and then placing them as textures onto any plane of a given 3D model. This process is called texture mapping.
240
Foundry
TSMC
Process Size
16 nm
Architecture
Pascal

Memory Specifications

Memory Size
24GB
Memory Type
GDDR5X
Memory Bus
The memory bus width refers to the number of bits of data that the video memory can transfer within a single clock cycle. The larger the bus width, the greater the amount of data that can be transmitted instantaneously, making it one of the crucial parameters of video memory. The memory bandwidth is calculated as: Memory Bandwidth = Memory Frequency x Memory Bus Width / 8. Therefore, when the memory frequencies are similar, the memory bus width will determine the size of the memory bandwidth.
384bit
Memory Clock
1808MHz
Bandwidth
Memory bandwidth refers to the data transfer rate between the graphics chip and the video memory. It is measured in bytes per second, and the formula to calculate it is: memory bandwidth = working frequency × memory bus width / 8 bits.
694.3 GB/s

Display and Media

Outputs
No outputs

Theoretical Performance

Pixel Rate
Pixel fill rate refers to the number of pixels a graphics processing unit (GPU) can render per second, measured in MPixels/s (million pixels per second) or GPixels/s (billion pixels per second). It is the most commonly used metric to evaluate the pixel processing performance of a graphics card.
147.0 GPixel/s
Texture Rate
Texture fill rate refers to the number of texture map elements (texels) that a GPU can map to pixels in a single second.
367.4 GTexel/s
FP16 (half)
An important metric for measuring GPU performance is floating-point computing capability. Half-precision floating-point numbers (16-bit) are used for applications like machine learning, where lower precision is acceptable. Single-precision floating-point numbers (32-bit) are used for common multimedia and graphics processing tasks, while double-precision floating-point numbers (64-bit) are required for scientific computing that demands a wide numeric range and high accuracy.
183.7 GFLOPS
FP64 (double)
An important metric for measuring GPU performance is floating-point computing capability. Double-precision floating-point numbers (64-bit) are required for scientific computing that demands a wide numeric range and high accuracy, while single-precision floating-point numbers (32-bit) are used for common multimedia and graphics processing tasks. Half-precision floating-point numbers (16-bit) are used for applications like machine learning, where lower precision is acceptable.
367.4 GFLOPS
FP32 (float)
An important metric for measuring GPU performance is floating-point computing capability. Single-precision floating-point numbers (32-bit) are used for common multimedia and graphics processing tasks, while double-precision floating-point numbers (64-bit) are required for scientific computing that demands a wide numeric range and high accuracy. Half-precision floating-point numbers (16-bit) are used for applications like machine learning, where lower precision is acceptable.
11.995 TFLOPS

Miscellaneous

SM Count
Multiple Streaming Processors (SPs), along with other resources, form a Streaming Multiprocessor (SM), which is also referred to as a GPU's major core. These additional resources include components such as warp schedulers, registers, and shared memory. The SM can be considered the heart of the GPU, similar to a CPU core, with registers and shared memory being scarce resources within the SM.
30
Shading Units
The most fundamental processing unit is the Streaming Processor (SP), where specific instructions and tasks are executed. GPUs perform parallel computing, which means multiple SPs work simultaneously to process tasks.
3840
L1 Cache
48 KB (per SM)
L2 Cache
3MB
TDP
250W
Vulkan Version
Vulkan is a cross-platform graphics and compute API by Khronos Group, offering high performance and low CPU overhead. It lets developers control the GPU directly, reduces rendering overhead, and supports multi-threading and multi-core processors.
1.3
OpenCL Version
3.0
OpenGL
4.6
CUDA
6.1
DirectX
12 (12_1)
Power Connectors
8-pin EPS
ROPs
The Raster Operations Pipeline (ROPs) is primarily responsible for handling lighting and reflection calculations in games, as well as managing effects like anti-aliasing (AA), high resolution, smoke, and fire. The more demanding the anti-aliasing and lighting effects in a game, the higher the performance requirements for the ROPs; otherwise, it may result in a sharp drop in frame rate.
96
Shader Model
6.7
Suggested PSU
600W

Benchmarks

FP32 (float)
Score
11.995 TFLOPS
Blender
Score
802
OctaneBench
Score
163

Compared to Other GPU

FP32 (float) / TFLOPS
12.603 +5.1%
12.485 +4.1%
11.995
11.567 -3.6%
11.113 -7.4%
Blender
2476 +208.7%
1399.99 +74.6%
802
391 -51.2%
191.62 -76.1%
OctaneBench
1328 +714.7%
163
86 -47.2%