context

// 64kB stack
#define FIBER_STACK 1024*64

#include "ucontext.h"
#include"stdlib.h"
#include "stdio.h"
ucontext_t child, parent;

// The child thread will execute this function
void threadFunction()
{
    printf( "Child fiber yielding to parent" );
    swapcontext( &child, &parent );
    printf( "Child thread exiting\n" );
    swapcontext( &child, &parent );
}

#include <unistd.h>
#include <pthread.h>
void* f(void *){


    printf( "thread end\n" );
    return 0;
}

int main()
{
    pthread_t d;
    pthread_create(&d,0,f,0);

    // Get the current execution context
    getcontext( &child );

    // Modify the context to a new stack
//    child.uc_link = 0;
    child.uc_stack.ss_sp = malloc( FIBER_STACK );
    child.uc_stack.ss_size = FIBER_STACK;
//    child.uc_stack.ss_flags = 0;
    if ( child.uc_stack.ss_sp == 0 )
    {
        perror( "malloc: Could not allocate stack" );
        exit( 1 );
    }


    // Create the new context
    printf( "Creating child fiber\n" );
    //makecontext( &child, &threadFunction, 0 );
    swapcontext( &parent, &child );


    printf( "Child fiber returned and stack freed\n" );

    sleep(3);
    // Execute the child context
    printf( "Switching to child fiber\n" );
    swapcontext( &parent, &child );
    printf( "Switching to child fiber again\n" );
    swapcontext( &parent, &child );

    sleep(3);

    // Free the stack
    free( child.uc_stack.ss_sp );
    printf( "main end\n" );

    return 0;
}

 

 

 

 

 

 

 

 

 

 

 

#include "ucontext.h"
#include "stdlib.h"
#include "memory.h"

#include "sys/types.h"

struct Task
{
    void *stack;
    uint stackSize;
    int state;
    ucontext_t context;
};

struct ThreadContext
{
    Task tasks[5];
};


enum{
    unused = 0,
    used,
};


void f(int a, int b){
    int k = a + b;
    ++k;
}


int main(int argc, char *argv[])
{
    ThreadContext scheduler;
    memset(&scheduler, 0, sizeof(scheduler));

    Task& mainTask = scheduler.tasks[0];
    mainTask.stackSize = 1 << 21;
    mainTask.stack = malloc(mainTask.stackSize);
    mainTask.state = used;

    for (uint i = 1; i < sizeof(scheduler.tasks)/ sizeof(*scheduler.tasks); ++i){
        Task& task = scheduler.tasks[i];
//        task.stack = 0;
//        task.stackSize = 0;
        if (getcontext(&task.context))
            exit(3);
        task.context.uc_stack.ss_sp = mainTask.stack;
        task.context.uc_stack.ss_size = mainTask.stackSize;
    }

    Task& task = scheduler.tasks[1];
    makecontext(&task.context, (void (*)())f, 2, 4, 6);
    if (swapcontext(&mainTask.context, &task.context))
        exit(4);


    for (uint i = 0; i < sizeof(scheduler.tasks)/ sizeof(*scheduler.tasks); ++i){
        Task& task = scheduler.tasks[i];
        if (task.stack)
            free(task.stack);
    }
    return 0;
}