Stack allocation

Each thread has its own stack that you can allocate yourself or have the system manage.

The pthread_attr_t structure includes members that specify a new thread's stack address and size; pthread_attr_init() sets the default values, and you can use pthread_attr_setstackaddr() and pthread_attr_setstacksize() to override them. The values of the stack address and size members of this structure control the type of stack allocation that occurs when you create a thread:

Stack address Stack size Allocation
NULL 0 Automatic (the default)
NULL Desired size Partly automatic
Non-NULL Size of the allocated area Manual

Let's compare the types of allocation:

The process manager allocates a stack of the default size, 128 KB, in virtual memory. The stack is followed by a read-only guard page that the process manager uses to detect stack overflow.

Initially, only part of the stack is allocated in physical memory. This portion contains the thread local storage (TLS) and other system data that's specific to the thread. The process manager allocates additional 4 KB pages of physical memory when required. The guard page exists only in virtual memory; there's no physical memory allocated for it.

When the thread exits, the process manager automatically deallocates the stack.

Partly automatic
The process manager allocates a stack of the size that you specified, rounded up to a multiple of the page size (4 KB). The space is allocated in virtual memory, with a guard page, and the process manager looks after the stack as it does for automatic allocation.
The process manager uses the stack that you allocated for the thread. It's up to you to allocate enough space for the thread, and no guard page is provided. The process manager doesn't deallocate the stack when the thread exits.
Note: If you specify a stack size (for partly automatic or manual allocation), it should be the size that you want plus PTHREAD_STACK_MIN, which is the amount of space that the thread needs for its thread local storage and other overhead.

A process’s main thread starts with an automatically allocated 512 KB stack, but it isn’t deleted when the main thread goes away (e.g., calls pthread_exit() or is cancelled). The main thread’s stack includes the command-line arguments and environment variables, which other threads might still need. To specify the stack size for the main thread, use qcc's -N option.

The output of the pidin mem command uses an asterisk (*) to indicate a stack that isn't automatically returned to the system heap when the thread exits.