Why are OpenGL and CUDA contexts memory greedy?

Question

I develop software which usually includes both OpenGL and Nvidia CUDA SDK. Recently, I also started to seek ways to optimize run-time memory footprint. I noticed the following (Debug and Release builds differ only by 4-7 Mb):

Application startup - Less than 1 Mb total

OpenGL 4.5 context creation ( + GLEW loader init) - 45 Mb total

CUDA 8.0 context (Driver API) creation 114 Mb total.

If I create OpenGL context in "headless" mode, the GL context uses 3 Mb less, which probably goes to default frame buffers allocation. That makes sense as the window size is 640x360.

So after OpenGL and CUDA context are up, the process already consumes 114 Mb.

Now, I don't have deep knowledge regarding OS specific stuff that occurs under the hood during GL and CUDA context creation, but 45 Mb for GL and 68 for CUDA seems a whole lot to me. I know that usually several megabytes goes to system frame buffers, function pointers,(probably a bulk of allocations happens on driver side). But hitting over 100 Mb with just "empty" contexts looks too much.

I would like to know:

1. Why GL/CUDA context creation consumes such a considerable amount of memory?

2. Are there ways to optimize that?

The system setup under test: Windows 10 64bit. NVIDIA GTX 960 GPU (Driver Version:388.31). 8 Gb RAM. Visual Studio 2015, 64bit C++ console project.

I measure memory consumption using Visual Studio built-in Diagnostic Tools -> Process Memory section.

UPDATE

I tried Process Explorer, as suggested by datenwolf. Here is the screenshot of what I got, (my process at the bottom marked with yellow):

I would appreciate some explanation on that info. I was always looking at "Private Bytes" in "VS Diagnostic Tools" window. But here I see also "Working Set", "WS Private" etc. Which one correctly shows how much memory my process currently uses? 281,320K looks way too much, because as I said above, the process at the startup does nothing, but creates CUDA and OpenGL contexts.

Answer 1

Partial answer: This is an OS-specific issue; on Linux, CUDA takes 9.3 MB.

---

I'm using CUDA (not OpenGL) on GNU/Linux:

• CUDA version: 10.2.89
• OS distribution: Devuan GNU/Linux Beowulf (~= Debian Buster without systemd)
• Kernel: Linux 5.2.0
• Processor: Intel x86_64

To check how much memory gets used by CUDA when creating a context, I ran the following C program (which also checks what happens after context destruction):

#include <stdio.h>
#include <cuda.h>
#include <malloc.h>
#include <stdlib.h>

static void print_allocation_stats(const char* s)
{
    printf("%s:\n", s);
    printf("--------------------------------------------------\n");
    malloc_stats();
    printf("--------------------------------------------------\n\n");
}

int main()
{
    display_mallinfo("Initially");

    int status = cuInit(0);
    if (status != 0 ) { return EXIT_FAILURE; }
    print_allocation_stats("After CUDA driver initialization");

    int device_id = 0;
    unsigned flags = 0;
    CUcontext context_id;
    status = cuCtxCreate(&context_id, flags, device_id);
    if (status != CUDA_SUCCESS ) { return EXIT_FAILURE; }
    print_allocation_stats("After context creation");

    status = cuCtxDestroy(context_id);
    if (status != CUDA_SUCCESS ) { return EXIT_FAILURE; }
    print_allocation_stats("After context destruction");
    return EXIT_SUCCESS;
}

(note that this uses a glibc-specific function, not in the standard library.)

Summarizing the results and snipping irrelevant parts:

Point in program	Total bytes	In-use	Max MMAP Regions	Max MMAP bytes
Initially	135168	1632	0	0
After CUDA driver initialization	552960	439120	2	307200
After context creation	9314304	6858208	8	6643712
After context destruction	7016448	580688	8	6643712

So CUDA starts with 0.5 MB and after allocating a context takes up 9.3 MB (going back down to 7.0 MB on destroying the context). 9 MB is still a lot of memory for not having done anything; but - maybe some of it is all-zeros, or uninitialized, or copy-on-write, in which case it doesn't really take up that much memory.

It's possible that memory use improved dramatically over the two years between the driver release with CUDA 8 and with CUDA 10, but I doubt it. So - it looks like your problem is Windows specific.

Also, I should mention I did not create an OpenGL context - which is another part of OP's question; so I haven't estimated how much memory that takes. OP brings up the question of whether the sum is greater than its part, i.e. whether a CUDA context would take more memory if an OpenGL context existed as well; I believe this should not be the case, but readers are welcome to try and report...