使用makecontext实现用户线程

使用makecontext实现用户线程

       现代Unix系统都在ucontext.h中提供用于上下文切换的函数，这些函数有getcontext, setcontext，swapcontext 和makecontext。其中，getcontext用于保存当前上下文，setcontext用于切换上下文，swapcontext会保存当前上下文并切换到另一个上下文，makecontext创建一个新的上下文。实现用户线程的过程是：我们首先调用getcontext获得当前上下文，然后修改ucontext_t指定新的上下文。同样的，我们需要开辟栈空间，但是这次实现的线程库要涉及栈生长的方向。然后我们调用makecontext切换上下文，并指定用户线程中要执行的函数。
       在这种实现中还有一个挑战，即一个线程必须可以主动让出CPU给其它线程。swapcontext函数可以完成这个任务，图4展示了一个这种实现的样例程序，child线程和parent线程不断切换以达到多线程的效果。在libfiber-uc.c文件中可以看到完整的实现。

#include 
#include 
#include 

// 64kB stack
#define FIBER_STACK 1024*64

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 );
}

int main()
{
// 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 );

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

// Free the stack
free( child.uc_stack.ss_sp );

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

return 0;
}
图4用makecontext实现线程

用户级线程的抢占

       抢占实现的一个最重要的因素就是定时触发的计时器中断，它的存在使得我们能够中断当前程序的执行，异步对进程的时间片消耗情况进行统计，并在必要的时候（可能是时间片耗尽，也可能是一个高优先级的程序就绪）从当前进程调度到其它进程去执行。

       对于用户空间程序来说，与内核空间的中断相对应的就是信号，它和中断一样都是异步触发，并能引起执行流的跳转。所以要想实现用户级线程的抢占，我们可以借助定时器信号(SIGALRM)，必要时在信号处理程序内部进行上下文的切换。

       为了验证自己的想法，我在上篇文章提到的协同多线程的基础上加上了相关抢占代码，具体实现如下：

#include 
#include 
#include 
#include 

#define STACK_SIZE 4096
#define UTHREAD_MAX_NUM 256
#define INIT_TICKS 10

typedef int uthread_t;
typedef void uthread_attr_t;
uthread_t current = 0;

#define uthread_self() current

struct uthread_struct
{
        int used;
        ucontext_t context;
        char stack[STACK_SIZE];
        void* (*func)(void *arg);
        void *arg;
        void *exit_status;
        int ticks;
};

static struct uthread_struct uthread_slots[UTHREAD_MAX_NUM];

void panic(void)
{
                fprintf(stderr, "Panic, bala bala...\n");
                exit(EXIT_FAILURE);
}

void idle_thread(void)
{
        int i;

        for (i = 1; i < UTHREAD_MAX_NUM; i ++)
                if (uthread_slots[i].used)
                        break;

        if (i == UTHREAD_MAX_NUM)
                panic();
        if (current != 0)
                uthread_slots[current].used = 0;
        current = i;
        swapcontext(&uthread_slots[0].context,&uthread_slots[current].context);
}

void uthread_context_init(int tid)
{
        getcontext(&uthread_slots[tid].context);
        uthread_slots[tid].context.uc_stack.ss_sp = uthread_slots[tid].stack;
        uthread_slots[tid].context.uc_stack.ss_size =sizeof(uthread_slots[tid].stack);
        uthread_slots[tid].context.uc_link = &uthread_slots[0].context;
}

void uthread_init(void)
{
        uthread_context_init(0);
        uthread_slots[0].used = 1;
        makecontext(&uthread_slots[0].context, idle_thread, 0);
}

void uthread_schedule(void);

void uthread_exit(void *exit_status)
{
        uthread_slots[current].exit_status = exit_status;
        uthread_slots[current].used = 0;
        uthread_schedule();
}

void uthread_helper(void)
{
        uthread_exit(uthread_slots[current].func(uthread_slots[current].arg));
}

int uthread_create(uthread_t *thread, const uthread_attr_t *attr,
                        void* (*start_routine)(void*), void *arg)
{
        static int last_used = 0;
        int i;

        for (i = (last_used + 1) % UTHREAD_MAX_NUM; i != last_used;
                        i = (i + 1) % UTHREAD_MAX_NUM)
                if (!uthread_slots[i].used)
                        break;
        if (i == last_used)
                return -1;
        last_used = i;

        if (thread != NULL)
                *thread = i;
        uthread_context_init(i);
        uthread_slots[i].used = 1;
        uthread_slots[i].func = start_routine;
        uthread_slots[i].arg = arg;
        uthread_slots[i].exit_status = 0;
        uthread_slots[i].ticks = uthread_slots[current].ticks / 2;
        uthread_slots[current].ticks -= uthread_slots[i].ticks;
        makecontext(&uthread_slots[i].context, uthread_helper, 0);

        return 0;
}

void uthread_schedule(void)
{
        int i, prev;

        for (i = (current + 1) % UTHREAD_MAX_NUM; i != current;
                        i = (i + 1) % UTHREAD_MAX_NUM)
                if (uthread_slots[i].used)
                        break;
        if (i == current)
                panic();

        prev = current;
        current = i;
        swapcontext(&uthread_slots[prev].context,&uthread_slots[current].context);
}

void* thread(void *arg)
{
        int i;

        for (i = 0; 1; i ++) {
                if (i % 1000 == 0)
                        printf("thread/%d(%s): i = %d\n", current, (char*)arg,i);
                uthread_create(NULL, NULL, thread, arg);
                if (i % 1000000 == 0)
                uthread_schedule();
        }
}

void sig_ticks_timer(int signo)
{
        if (--uthread_slots[current].ticks <= 0) {
                uthread_slots[current].ticks = INIT_TICKS;
                uthread_schedule();
        }
}

int main(int argc, char *argv[])
{
        uthread_t tid;
        struct itimerval ticks_timer;

        uthread_init();

        uthread_create(&tid, NULL, thread, "hw1");
        printf("tid is %d\n", tid);
        uthread_create(&tid, NULL, thread, "hw2");
        printf("tid is %d\n", tid);

        signal(SIGALRM, sig_ticks_timer);
        ticks_timer.it_interval.tv_sec = 0;
        ticks_timer.it_interval.tv_usec = 10000;
        ticks_timer.it_value.tv_sec = 0;
        ticks_timer.it_value.tv_usec = 10000;
        setitimer(ITIMER_REAL, &ticks_timer, NULL);

        while (1)
                idle_thread();

        return 0;
}

       似乎该有的都有了，也许真的可以在用户空间实现一个虚拟的操作系统环境玩呢...