云风协程库保存和恢复协程运行栈原理讲解

青旅半醒 2021-09-29 07:24 271阅读 0赞

首先， `linux`下的进程地址空间布局是这样子的：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdXNoZW5neGlfcm9vdA_size_16_color_FFFFFF_t_70]

可以看到 **整个进程地址空间从上到下地址变化是从高地址到低地址的！** 32 位系统有 4G 的地址空间，其中`0x08048000`\-> `0xbfffffff` 是用户空间，`0xc0000000`~`0xffffffff` 是内核空间，包括内核代码和数据、与进程相关的数据结构（如页表、内核栈）等。其实就是大体上就是下面这样：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdXNoZW5neGlfcm9vdA_size_16_color_FFFFFF_t_70 1]

另外， `%esp 执行栈顶，往低地址方向变化； brk/sbrk 函数控制堆顶往高地址方向变化`。也就是说栈是向下生长的．（堆向上生长，这样可以充分利用空间）

知道了这些，我们就可以开心的来看代码了*＾-＾*

# 保存现场: #

协程在从 `RUNNING` 到 `SUSPEND` 状态时需要保存运行栈，即调用 `coroutine_yield` 之后挂起协程，让出CPU的过程。

原理：就是`将该协程运行时候的所有数据转而存储到每个协程所对应的结构中，为了在下次回到这个协程时能回到之前的执行点继续执行`，那么你会想问，那这个协程运行的时候的栈在哪？我们来看代码：

C->ctx.uc_stack.ss_sp = S->stack; 
    C->ctx.uc_stack.ss_size = STACK_SIZE; 
    makecontext(&C->ctx, (void (*)(void)) mainfunc, 2, 
    (uint32_t)ptr, (uint32_t)(ptr>>32));

这是协程初始化时进行的设置．`我们可以看到schedule 的 stack[STACK_SIZE] 是子协程运行的公共栈空间！`该协程栈的栈顶设置为 **S->stack**，**mainfunc** 的运行使用 **S->stack** 作为栈顶，大小为 **STACK\_SIZE**．ｏｋ，一切搞定，那么`转储的时候其实就是将这个栈中该协程所用到的数据copy到它对应的结构中就行了`．

static void
    _save_stack(struct coroutine *C, char *top)
    { 
    	printf("top:%p \n", top);
    
    	char dummy = 0;
    	printf("dummy:%p \n", &dummy);
    	// top-&dummy 即该协程的运行时所占的空间大小
    	assert(top - &dummy <= STACK_SIZE);
    
    	printf("STACK_ZISE:%d \n", STACK_SIZE);
    	printf("top - &dummy:%ld \n", top - &dummy);
    	//如果协程私有栈空间大小(C->cap)不够放下运行时的栈空间，则要重新扩容
    	if (C->cap < top - &dummy)
    	{ 
    		free(C->stack);
    		C->cap = top - &dummy;
    		C->stack = malloc(C->cap);
    	}
    	C->size = top - &dummy; /*c->stack 是在堆上的*/
    	memcpy(C->stack, &dummy, C->size);
    	//将(dummy->top) 的数据copy到该协程对应的结构中就行了
    }
    
    void coroutine_yield(struct schedule *S)
    { 
    	int id = S->running;
    	assert(id >= 0);
    	struct coroutine *C = S->co[id];
    	assert((char *)&C > S->stack);
    
    	printf("S->stack ==%p\n", S->stack);
    	printf("S->stack+STACK_SIZE ==%p\n", S->stack + STACK_SIZE);
       //为了在下次回到这个协程时能回到之前的执行点继续执行，必须要保存其执行的上下文
    
    	_save_stack(C, S->stack + STACK_SIZE);
    
    	C->status = COROUTINE_SUSPEND;
    	S->running = -1;
    	swapcontext(&C->ctx, &S->main);
    }

关于`_save_stack()`函数，我画了这样的一幅图，相信你一看就能懂

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdXNoZW5neGlfcm9vdA_size_16_color_FFFFFF_t_70 2]

程序执行结果：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdXNoZW5neGlfcm9vdA_size_16_color_FFFFFF_t_70 3]  
1.　可以看到`S->stack+STACK_SIZE`地址值大于`S->stack`,所以他在高地址．  
2.　`dummy`介于两者之间，`> S->stack` ,`< S->stack+STACK_SIZE`．因为我们没有用到什么数据，所以`dummy`的地址很靠近`< S->stack+STACK_SIZE`．  
3.　证明上面画得图是正确的．

# 恢复现场: #

协程从 `SUSPEND` 到 `RUNNING` 状态时，是要恢复当时的运行栈，回到执行点再执行的．

原理：`将各自私有的C->stack 空间中的数据恢复到S->stack中`

// C->size 表示协程似有栈的实际大小
    memcpy(S->stack + STACK_SIZE - C->size, C->stack, C->size);

至此，该原理就讲解到这儿了，你理解了吗？？

转载于:https://www.cnblogs.com/Tattoo-Welkin/p/10335249.html

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdXNoZW5neGlfcm9vdA_size_16_color_FFFFFF_t_70]: /images/20210725/ba5db20a71204657ab29f8d8edf202cf.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdXNoZW5neGlfcm9vdA_size_16_color_FFFFFF_t_70 1]: /images/20210725/72f1b0e90fa74f30a52c0a26fa417fa2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdXNoZW5neGlfcm9vdA_size_16_color_FFFFFF_t_70 2]: /images/20210725/53183abb8252469188f176a8adcefa78.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdXNoZW5neGlfcm9vdA_size_16_color_FFFFFF_t_70 3]: /images/20210725/ac0e8a5a3bb841e6967bdf36c5257989.png