Creating and using a new stack in memory

Question

For some special reasons (please don't ask me why), for some functions, I want to use a separate stack. So for example, say I want the function malloc to use a different stack for its processing, I need to switch to my newly created stack before it is called and get back to the original stack used by the program after it finishes. So the algorithm would be something like this.

switch_to_new_stack
call malloc
swith back to the original stack

What is the easiest and most efficient way of doing this? Any idea?

Threads run with their own stack; you could create a thread to run the malloc; the caller would do nothing but wait for the thread to complete. — antlersoft
– antlersoft, Commented Aug 31, 2011 at 17:00
+1. It's a simple question, switching to a new stack is a well-understood operation, the only things in doubt are whether it's possible in user-mode in linux (the gist of the question) and why the questioner wants to do it (the gist of the comments, but irrelevant to the answer: either there's a way to do it that's portable across linux on different architectures, or there isn't, and this holds regardless of whether the questioner would be better advised to do something else instead). Also, SO is nagging me to vote on questions more. — Steve Jessop
– Steve Jessop, Commented Aug 31, 2011 at 17:07
Any solution will be system-specific. The C language standard doesn't even use the word "stack", and there have been real-world C implementations that don't use a contiguous stack for allocation of objects with automatic storage duration (think of a heap-allocated linked list of activation records). I trust you're aware that the space allocated by malloc isn't on the stack; any stack space used by malloc is going to be local to the call itself, and will be released as soon as malloc returns. I can only take your word for it that you need to do this, but I can't think of a good reason. — Keith Thompson
– Keith Thompson, Commented Aug 31, 2011 at 17:35

user786653 · Accepted Answer · 2011-08-31 20:14:56Z

It probably doesn't fit your definition of easy or efficient, but the following could be one way to do it:

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

#include <ucontext.h>

/* utility functions */
static void getctx(ucontext_t* ucp)
{
    if (getcontext(ucp) == -1) {
        perror("getcontext");
        exit(EXIT_FAILURE);
    }
}

static void print_sp()
{
#if defined(__x86_64)
    unsigned long long x; asm ("mov %%rsp, %0" : "=m" (x));
    printf("sp: %p\n",(void*)x);
#elif defined(__i386)
    unsigned long x; asm ("mov %%esp, %0" : "=m" (x));
    printf("sp: %p\n",(void*)x);
#elif defined(__powerpc__) && defined(__PPC64__)
    unsigned long long x; asm ("addi %0, 1, 0" : "=r" (x));
    printf("sp: %p\n",(void*)x);
#elif defined(__powerpc__)
    unsigned long x; asm ("addi %0, 1, 0" : "=r" (x));
    printf("sp: %p\n",(void*)x);
#else
    printf("unknown architecture\n");
#endif
}


/* stack for 'my_alloc', size arbitrarily chosen */
static int malloc_stack[1024];
static ucontext_t malloc_context; /* context malloc will run in */
static ucontext_t current_context; /* context to return to */

static void my_malloc(size_t sz)
{
    printf("in my_malloc(%zu) ", sz);
    print_sp();
}

void call_my_malloc(size_t sz)
{
    /* prepare context for malloc */
    getctx(&malloc_context);
    malloc_context.uc_stack.ss_sp = malloc_stack;
    malloc_context.uc_stack.ss_size = sizeof(malloc_stack);
    malloc_context.uc_link = &current_context;
    makecontext(&malloc_context, (void(*)())my_malloc, 1, sz);

    if (swapcontext(&current_context, &malloc_context) == -1) {
        perror("swapcontext");
        exit(EXIT_FAILURE);
    }
}

int main()
{
    printf("malloc_stack = %p\n", (void*)malloc_stack);
    printf("in main ");
    print_sp();
    call_my_malloc(42);
    printf("in main ");
    print_sp();
    return 0;
}

This should work on all platforms where makecontext(3) is supported. Quoting from the manpage (where I also got the inspiration for the example code):

The interpretation of ucp->uc_stack is just as in sigaltstack(2), namely, this struct contains the start and length of a memory area to be used as the stack, regardless of the direction of growth of the stack. Thus, it is not necessary for the user program to worry about this direction.

Sample output from PPC64:

$ gcc -o stack stack.c -Wall -Wextra -W -ggdb -std=gnu99 -pedantic -Werror -m64 && ./stack
malloc_stack = 0x10010fe0
in main sp: 0xfffffe44420
in my_malloc(42) sp: 0x10011e20
in main sp: 0xfffffe44420

osgx · Accepted Answer · 2011-08-31 21:26:32Z

GCC has support of splitted stacks, which works a bit like you described.

http://gcc.gnu.org/wiki/SplitStacks

The goal of the project is different, but implementation will do what you ask.

The goal of split stacks is to permit a discontiguous stack which is grown automatically as needed. This means that you can run multiple threads, each starting with a small stack, and have the stack grow and shrink as required by the program. It is then no longer necessary to think about stack requirements when writing a multi-threaded program. The memory usage of a typical multi-threaded program can decrease significantly, as each thread does not require a worst-case stack size. It becomes possible to run millions of threads (either full NPTL threads or co-routines) in a 32-bit address space.

Collectives™ on Stack Overflow

Creating and using a new stack in memory

2 Answers 2

1 Comment

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

1 Comment

Comments

Your Answer

Sign up or log in

Post as a guest

Related