2. 程式人生 > >使用 setcontext 類函式實現 mini 協程庫

使用 setcontext 類函式實現 mini 協程庫

阿新 • • 發佈：2019-01-02

協程實現原理

協程的本質都是通過修改 ESP 和 EIP 指標來實現的。其理論上還是單執行緒在執行．

程式在CPU上執行時依賴3個暫存器：

  1. ESP寄存值指向當前棧頂地址，指向當前指令需要的資料
  2. EBP指向當前活動棧幀的基地址
  3. 指令暫存器IP，指向當前需要執行的指令

其中主要有（IP,ESP）暫存器最重要，這兩個暫存器指標的改變可以修改當前需要載入到 CPU 執行的指令和資料，當某個操作陷入到耗時的等待中時，通過修改這兩個指標即可讓出CPU，交給其他的任務去使用，每個任務都必須主動的讓出CPU，然後等待下一次的排程來繼續未完成的任務，這樣就可以最大程度的利用CPU，當一個任務等待過程非常短的時候，就出現了多個任務並行執行的效果，也就是協程。

實現協程的多種方法

  1. 利用　glibc 的 ucontext 元件(雲風的庫)
  2. 使用匯編來切換上下文（實現miniC協程,騰訊libco)
  3. 利用C語言語法switch-case的奇淫技巧來實現（Protothreads)
  4. 利用了 C 語言的 setjmp 和 longjmp（ 一種協程的 C/C++ 實現,要求函式裡面使用 static local 的變數來儲存協程內部的資料）
  5. 利用Boost庫提供的兩種實現，分別是stackless與stackfull
  6. 等等語言和庫．．．．

當然了，最"厲害"的還是去用匯編去實現，因為這樣會避免許多跨平臺等問題．比如在有些平臺就會用不了setcontext

等函式．有些函式可能也慢慢的廢除了，所以用匯編實現是最有效的，也是騰訊公司經過多年的實踐得出的．

glibc庫裡的上下文操作函式：

1.getcontext()  : 獲取當前context
2.setcontext()  : 切換到指定context
3.makecontext() : 設定 函式指標 和 堆疊 到對應context儲存的 sp 和 pc 暫存器中,
			呼叫之前要先呼叫 getcontext()
4.swapcontext() : 儲存當前context，並且切換到指定context

具體使用可以自己查詢一下,最後我會用他們實現一個C++11協程庫．

如何實現儲存和恢復協程執行棧

例項：使用C++11和setcontext類函式實現協程庫

main.cpp

#include "Coroutine.h"

#include <iostream>
#include <stdio.h>
#include <unistd.h>
using namespace std;
using namespace Tattoo;

class TEST
{
  public:
	void func3(std::shared_ptr<CoroutineSchedule> s, void *arg)
	{
		for (int i = 0; i < 10; i++)
		{
			cout << "coroutine : " << s->GetCurCoID() << " : " << *(int *)arg + i << endl;
			s->Yield();
		}
	}
};

int main()
{
	std::shared_ptr<CoroutineSchedule> schedule = std::make_shared<CoroutineSchedule>();

	int test1 = 1;
	int test2 = 2;
	int test3 = 3;

	TEST tt;

	int id_co1 = schedule->CreateCoroutine(std::bind(&TEST::func3, &tt, schedule, &test1));
	int id_co2 = schedule->CreateCoroutine(std::bind(&TEST::func3, &tt, schedule, &test2));
	int id_co3 = schedule->CreateCoroutine(std::bind(&TEST::func3, &tt, schedule, &test3));

	printf("main start\n");
	while ((schedule->IsAlive(id_co1)) && (schedule->IsAlive(id_co2)) && (schedule->IsAlive(id_co3)))
	{
		schedule->ResumeCoroutine(id_co1);
		schedule->ResumeCoroutine(id_co2);
		schedule->ResumeCoroutine(id_co3);
	}
	printf("main end\n");

	return 0;
}

CoroutineSchedule.h


#ifndef _COROUTINESCHEDULER_H
#define _COROUTINESCHEDULER_H //B.h

#include <ucontext.h>
#include <unordered_map>
#include <memory>
#include <functional>
#include <iostream>

#define INFO(x, y, z) std::cout << x << " : " << y << " : " << z << std::endl;
namespace Tattoo
{

class Coroutine;
class CoroutineSchedule
{
  public:
	static const int STACK_SIZE = 1024 * 1024;
	static const int MAX_CO = 16;
	using CoFun = std::function<void()>;

	CoroutineSchedule() : cur_co_num_(0), cur_run_id_(-1) {}
	~CoroutineSchedule() {}

	CoroutineSchedule(const CoroutineSchedule &) = delete;
	CoroutineSchedule &operator=(const CoroutineSchedule &) = delete;

	int CreateCoroutine(CoFun func);
	void DestroyCroutine(int cor_id);
	void ResumeCoroutine(int cor_id);
	void Yield();

	bool IsAlive(int cor_id);
	int GetCurCoID() { return cur_run_id_; }

	static void static_fun(void *arg);

  private:
	std::unordered_map<int, std::shared_ptr<Coroutine>> mmap_;
	char SchStack[STACK_SIZE] = {0};
	ucontext_t main_ctx;
	int cur_co_num_; /*實時記錄協程數量,也會控制map下標*/
	int cur_run_id_;
};
} // namespace Tattoo
#endif

CoroutineSchedule.cpp


#include "Coroutine.h"

namespace Tattoo
{

int CoroutineSchedule::CreateCoroutine(CoFun func)
{
	/*這裡可以用 cur_max_num_　去限制協程數目*/
	cur_co_num_++;
	auto cor = std::make_shared<Coroutine>(this, func, cur_co_num_);
	mmap_[cur_co_num_] = cor;
	return cur_co_num_;
}
void CoroutineSchedule::DestroyCroutine(int cor_id)
{
	if (mmap_.find(cor_id) == mmap_.end())
		return;
	if (cor_id == cur_run_id_)
		cur_run_id_ = -1;
	mmap_[cor_id]->SetStatus(Coroutine::CO_FINSHED);
	cur_co_num_--; /*下次重複使用就行了，不需要 erase */
}
void CoroutineSchedule::Yield()
{
	if (-1 == cur_run_id_)
		return;
	int id = cur_run_id_;
	std::shared_ptr<Coroutine> cor = mmap_[id];
	// assert(reinterpret_cast<char *>(&cor) > );
	cor->save_stack(SchStack + STACK_SIZE);
	cor->SetStatus(Coroutine::CO_SUSPEND);
	cur_run_id_ = -1;
	swapcontext(&cor->ctx_, &main_ctx);
}
bool CoroutineSchedule::IsAlive(int cor_id)
{
	if (mmap_[cor_id]->GetStatus() == Coroutine::CO_FINSHED)
		return false;
	else
		return true;
}
void CoroutineSchedule::ResumeCoroutine(int cor_id)
{
	// INFO("*******************************************ResumeCoroutine", cor_id, cur_run_id_);

	if (mmap_.find(cor_id) == mmap_.end()) /*不存在的 id */
		return;

	assert(this->cur_run_id_ == -1); //保證沒有其他協程執行

	std::shared_ptr<Coroutine> cor = mmap_[cor_id];
	switch (cor->GetStatus())
	{
	case Coroutine::CO_READY:
	{
		getcontext(&cor->ctx_);
		cor->ctx_.uc_stack.ss_sp = SchStack;
		cor->ctx_.uc_stack.ss_size = STACK_SIZE;
		cor->ctx_.uc_link = &main_ctx;

		cur_run_id_ = cor_id;
		cor->SetStatus(Coroutine::CO_RUNNING);
		makecontext(&cor->ctx_, reinterpret_cast<void (*)()>(static_fun), 1, this);
		swapcontext(&this->main_ctx, &cor->ctx_);
	}
	break;
	case Coroutine::CO_SUSPEND:
	{
		memcpy(SchStack + STACK_SIZE - cor->stack_cur_size_, cor->CorStack, cor->stack_cur_size_);
		cur_run_id_ = cor_id;
		cor->SetStatus(Coroutine::CO_RUNNING);
		swapcontext(&main_ctx, &cor->ctx_);
	}
	break;
	default:
		assert(0);
	}
	if (-1 == cur_run_id_ && cor->status_ == Coroutine::CO_FINSHED)
		DestroyCroutine(cor_id);
}
void CoroutineSchedule::static_fun(void *arg)
{
	CoroutineSchedule *sch = reinterpret_cast<CoroutineSchedule *>(arg);
	int id = sch->cur_run_id_;
	std::shared_ptr<Coroutine> cor = sch->mmap_[id];
	cor->func_();

	sch->cur_run_id_ = -1;
	sch->mmap_[id]->SetStatus(Coroutine::CO_FINSHED);
}
} // namespace Tattoo

Coroutine.h


#ifndef _COROUTINE_H
#define _COROUTINE_H
#include <ucontext.h>
#include <memory>
#include <assert.h>
#include <string.h>
#include "CoroutineSchedule.h"

namespace Tattoo
{
class Coroutine
{
  public:
	using CoFun = std::function<void()>;
	enum
	{
		CO_FINSHED,
		CO_READY,
		CO_RUNNING,
		CO_SUSPEND,
	};
	Coroutine(CoroutineSchedule *sch, CoFun func, int id);
	~Coroutine();

	Coroutine(const Coroutine &) = delete;
	Coroutine &operator=(const Coroutine &) = delete;

	void SetStatus(int status);
	int GetStatus();

  private:
	friend class CoroutineSchedule;

	void save_stack(void *top);

	CoFun func_;
	ucontext_t ctx_;
	std::shared_ptr<CoroutineSchedule> sch_;
	std::ptrdiff_t stack_max_size_; //stack最大 大小
	std::ptrdiff_t stack_cur_size_; //協程實際大小
	int status_;
	char *CorStack;
	int id_;
};
} // namespace Tattoo
#endif

Coroutine.cpp


#include <ucontext.h>
#include <memory>
#include <assert.h>
#include <string.h>

#include "Coroutine.h"

namespace Tattoo
{
Coroutine::Coroutine(CoroutineSchedule *sch, CoFun func, int id)
	: func_(func), id_(id), sch_(sch),
	  stack_max_size_(0), stack_cur_size_(0),
	  status_(CO_READY), CorStack(0)
{
}
Coroutine::~Coroutine()
{
	delete[] CorStack;
}

void Coroutine::SetStatus(int status)
{
	status_ = status;
}
int Coroutine::GetStatus()
{
	return status_;
}
void Coroutine::save_stack(void *top)
{
	char dummy = 0;

	assert((char *)top - &dummy <= CoroutineSchedule::STACK_SIZE);

	if (stack_max_size_ < (char *)top - &dummy)
	{
		delete[] CorStack;
		stack_max_size_ = (char *)top - &dummy;
		CorStack = new char[stack_max_size_];
	}
	stack_cur_size_ = (char *)top - &dummy;
	memcpy(CorStack, &dummy, stack_cur_size_);
}
} // namespace Tattoo

執行截圖:

在這裡插入圖片描述

因為我的目標是用匯編去實現，所以也就不花時間去優化程式碼了（比如裡面還存在原始指標，new,delete ，記憶體洩露等）．

相關推薦

使用 setcontext 類函式實現 mini 協程庫

協程實現原理 協程的本質都是通過修改 ESP 和 EIP 指標來實現的。其理論上還是單執行緒在執行． 程式在CPU上執行時依賴3個暫存器： ESP寄存值指向當前棧頂地址，指向當前指令需要的資料 EBP指向當前活動棧幀的基地址 指令暫存器IP，指向當前需要執

ucontext-人人都可以實現的簡單協程庫

1.乾貨寫在前面 協程是一種使用者態的輕量級執行緒。本篇主要研究協程的C/C++的實現。 首先我們可以看看有哪些語言已經具備協程語義： 比較重量級的有C#、erlang、golang*輕量級有python、lua、javascript、ruby還有函式式的scala、scheme等。 c/c++不直接支

從無到有實現.net協程(一)

name 叠代器 out 之前 ring args ren 執行 images 協程的概念，就我而言，來源自當初學習Go，它可以用一句話來總結，“單線程無阻塞異步處理”，也就是說，首先，它的範圍是針對單個線程來說的，一個線程可以運行多個代碼片段，當運行期間遇到IO等待（包括

Python多任務實現 之協程並發下載多圖片

python 協程多任務 協程是Python中實現多任務一種方式，相比多任務之進程和線程，協程不需要消耗過多的資源，更高效的利用了cpu資源。 在Python中通過gevent封裝generator叠代器功能實現多任務的切換。協程在運行過程中是靠程序的耗時操作來實現程序中斷。達到切換多任務。至始至終，

00.用 yield 實現 Python 協程

cin before 加鎖 控制 gen 並且 占用 uci 遇到 來源：Python與數據分析 鏈接： https://mp.weixin.qq.com/s/GrU6C-x4K0WBNPYNJBCrMw 什麽是協程 引用官方的說法： 協程是一種用戶態的輕量級線程，協程的

(轉)通過組合語言實現C協程

轉自：http://www.cnblogs.com/sniperHW/archive/2012/06/19/2554574.html 協程的概念就不介紹了,不清楚的同學可以自己google,windows和unix like系統本身就提供了協程的支援,windows下叫fiber,unix like系統下叫

(轉)通過匯編語言實現C協程

mov fine ext https context nbsp make oid reat 轉自：http://www.cnblogs.com/sniperHW/archive/2012/06/19/2554574.html 協程的概念就不介紹了,不清楚的同學可以自己goo

Java 中atomic 類底層機制、協程

1、Java 中atomic 類底層機制 atomic類：AtomicInteger 等，其底層使用CAS機制，CAS 的底層實現時unsafe的compareAndSwapInt(this,valueOffset, expect, update)方法，其保證V , A, B 的原子性；CAS

單執行緒實現併發——協程，gevent模組

一 併發的本質   　　1 切換 　　2 儲存狀態 二 協程的概念 　　協程，又稱微執行緒，纖程。英文名Coroutine。單執行緒下實現併發，使用者從應用程式級別控制單執行緒下任務的切換，注意一定是遇到I/O才切。 　　協程的特點在於是一個執行緒執行，那和多執行緒比，協程有何優勢？ 　

Linux socket 資料傳送類函式實現(三)

注：本文分析基於3.10.0-693.el7核心版本，即CentOS 7.4 上回我們說到send四兄弟在sock_sendmsg()完成集合，write家族也在__sock_sendmsg()處等待。 其實sock_sendmsg()的下一步就是進入__s

雲風協程庫儲存和恢復協程執行棧原理講解

   首先， linux下的程序地址空間佈局是這樣子的： 可以看到 整個程序地址空間從上到下地址變化是從高地址到低地址的！ 32 位系統有 4G 的地址空間，其中0x08048000-> 0xbfffffff 是使用者空間，0xc0000000~0xffffffff 是核

libco協程庫原理解析與應用

       最近在準備一個libco協程庫原理簡析與應用的分享，順便就整理下寫個部落格，一方面加深下自己對協程庫的理解，另一方面也希望能對想了解協程的學者有所幫助。廢話不多說了，言歸正傳吧。        想去剖析libco協程庫的實現原理，首先我們要了解下什麼是協程。維基

去重的類函式實現

# -*- coding: utf-8 -*- import pandas as pd import numpy as np import jieba.posseg as pseg import codecs from gensim import corpora, models, similari

C/C++協程庫libco：微信怎樣漂亮地完成非同步化改造

如今，微信擁有月活躍使用者8億。 不可否認，當今的微信後臺擁有著強大的併發能力。 不過， 正如羅馬並非一日建成；微信的技術也曾經略顯稚嫩。 微信誕生於2011年1月，當年使用者規模為0.1億左右；2013年11月，微信月活躍使用者數達到3.55億，一躍成為亞洲地區擁有最大

騰訊協程庫libco的原理分析

我們以example_echosvr.cpp為例子，這個例子的作用就是讀取客戶端的請求，然後按原樣返回給客戶端。在它的main函式裡建立了proccnt程序，每個程序裡有cnt個task。這裡的proccnt和cnt都是來自執行引數。 for(int

Linux socket 資料傳送類函式實現(一)

注：本文分析基於3.10.0-693.el7核心版本，即CentOS 7.4 三次握手完成了，下面就該傳送資料了。傳送資料使用的函式有很多，比如send、sendto、sendmsg、sendmmsg，甚至還有write、wirtev等，那這些函式都是怎麼將資

libco協程庫上下文切換原理詳解

位置 同學 tps 容易 減少 char call 語言 size 緣起 libco 協程庫在單個線程中實現了多個協程的創建和切換。按照我們通常的編程思路，單個線程中的程序執行流程通常是順序的，調用函數同樣也是 “調用——返回&rdqu

微信協程庫libco簡單分析

eventloop 可能 RoCE man xevent lag fir wan 簡單 一、進程的等待以及對CPU資源的釋放 在整個框架下，系統將通過co_eventloop阻塞進入系統調用。這個很容易理解，一個進程不可能一直在空跑，所以在不需要系統信息的時候就可以讓操作

python網路-多工實現之協程

一、協程 協程，又稱微執行緒，纖程。英文名Coroutine。 協程不是程序，也不是執行緒，它就是一個函式，一個特殊的函式——可以在某個地方掛起，並且可以重新在掛起處繼續執行。所以說，協程與程序、執行緒相比，不是一個維度的概念。 一個程序可以包含多個執行緒，一個執行緒也可以包含多

深入理解協程（二）：yield from實現非同步協程

原創不易，轉載請聯絡作者 深入理解協程分為三部分進行講解： 協程的引入 yield from實現非同步協程 async/await實現非同步協程 本篇為深入理解協程系列文章的第二篇。 yield from yield from是Python3.3（PEP 380）引入的新語法。主要用於解決在生成器