Introduction

In TensorFlow r1.x, the runtime often tries to reserve most GPU memory unless you tell it otherwise. When using the C API, the important detail is that GPU limits are configured through serialized session options, which means the low-level C entry point still depends on a ConfigProto payload describing memory behavior.

The Core Settings That Matter

The two settings most people care about are:

• 'allow_growth, which lets TensorFlow allocate GPU memory gradually instead of preallocating almost everything'
• 'per_process_gpu_memory_fraction, which caps the fraction of GPU memory the process may reserve'

These settings live inside GPUOptions, which is nested inside ConfigProto.

Pass a Serialized ConfigProto to TF_SetConfig

The C API itself accepts session configuration bytes through TF_SetConfig. In practice, many projects build those bytes from TensorFlow protobuf definitions in C++.

1#include <tensorflow/c/c_api.h>
2#include <tensorflow/core/protobuf/config.pb.h>
3#include <iostream>
4#include <string>
5
6int main() {
7    TF_Status* status = TF_NewStatus();
8    TF_SessionOptions* options = TF_NewSessionOptions();
9
10    tensorflow::ConfigProto config;
11    config.mutable_gpu_options()->set_allow_growth(true);
12    config.mutable_gpu_options()->set_per_process_gpu_memory_fraction(0.40);
13
14    std::string serialized;
15    config.SerializeToString(&serialized);
16
17    TF_SetConfig(options, serialized.data(), serialized.size(), status);
18    if (TF_GetCode(status) != TF_OK) {
19        std::cerr << TF_Message(status) << std::endl;
20        return 1;
21    }
22
23    // create graph and session here
24
25    TF_DeleteSessionOptions(options);
26    TF_DeleteStatus(status);
27    return 0;
28}

That is the key mechanism: build a valid config, serialize it, and pass the bytes to the C API.

When to Use allow_growth

allow_growth is often the safest first setting in shared environments.

config.mutable_gpu_options()->set_allow_growth(true);

With this enabled, TensorFlow starts small and requests more GPU memory only as needed. This is useful when:

• several processes share one GPU
• you are not sure how much memory the model will actually need
• you want to reduce aggressive startup reservation

It does not give hard isolation, but it prevents the most common "grab everything immediately" behavior.

When to Use a Memory Fraction

If you need a firmer cap, set a per-process fraction.

config.mutable_gpu_options()->set_per_process_gpu_memory_fraction(0.25);

This tells TensorFlow to reserve at most about 25 percent of visible GPU memory for that process. The right value depends on the model, batch size, and whether other GPU consumers are active.

Be conservative first. If the cap is too low, you may simply turn an overallocation problem into out-of-memory failures during execution.

Understand the C API Limitation

A subtle point is that the pure C API does not give you nice field-by-field builders for ConfigProto. It accepts the serialized config blob. That is why many C-API users still rely on C++ protobuf code or pre-generated configuration bytes at build time.

So even though the runtime entry point is TF_SetConfig, the configuration authoring step is usually easier in C++ than in plain C.

Verify the Effect at Runtime

After applying the configuration, validate the behavior with system tools.

nvidia-smi

Watch memory usage as the session starts and as the workload runs. If TensorFlow still reserves more memory than expected, double-check that the session options you configured are actually the ones used to create the session.

Common Pitfalls

A common mistake is constructing the ConfigProto correctly but forgetting to call TF_SetConfig before creating the session.

Another is assuming allow_growth and memory fraction should always be combined. Sometimes allow_growth alone is enough, and a strict fraction just adds unnecessary failure risk.

Developers also sometimes call this the "C API" solution while depending on C++ protobuf definitions. That is normal in practice, but it is worth stating explicitly so the build setup is not surprising.

Summary

• TensorFlow r1.x GPU limits are controlled through ConfigProto session settings.
• The C API consumes those settings through TF_SetConfig as serialized bytes.
• 'allow_growth is useful when you want TensorFlow to allocate GPU memory gradually.'
• 'per_process_gpu_memory_fraction is useful when you need a harder cap.'
• In practice, many projects generate the config bytes using TensorFlow's C++ protobuf types before passing them into the C API.