Shulou(Shulou.com)06/02 Report--

Collaborative process has been a concept for a long time, many programmers have implemented this component, online articles, blogs, forums are full of sweat, in Zhihu, github above there are a lot of Daniel wrote about the experience of collaborative process. On a whim, I also came to implement such a component and tested its performance. Learn from a lot of Daniel's ideas, read a lot of Daniel's code. So write down the whole thinking process. Implementation code https://github.com/wangbojing/NtyCo

The code is easy to read, and if NtyCo can solve some engineering problems for you in your project, you will be honored.

The following will be part of the NtyCo code posted.

NtyCo supports multicore and multi-processes.

Int process_bind (void) {int num = sysconf (_ SC_NPROCESSORS_CONF); pid_t self_id = syscall (_ _ NR_gettid); printf ("selfid->% d\ n", self_id); cpu_set_t mask; CPU_ZERO (& mask); CPU_SET (self_id% num, & mask); sched_setaffinity (0, sizeof (mask), & mask) Mulcore_entry (9096 + (self_id num) * 10);}

NtyCo context switching

First of all, let's review the relevant knowledge of x86per64 registers. The registers of x86'64 have 16 64-bit registers, namely:% rax,% rbx,% rcx,% esi,% edi,% rbp,% rsp,% R8,% R9,% R10,% R11,% R12

% R13,% R14,% R15.

Rax is used as the return value of the function.

% rsp stack pointer register, pointing to the top of the stack

% rdi,% rsi,% rdx,% rcx,% R8,% R9 are used as function parameters, corresponding to the first parameter, the second parameter in turn.

% rbx,% rbp,% R12,% R13,% R14,% R15 are used as data stores, following the caller usage rules, in other words, casually. Back up the subfunction before calling it in case it is modified

% R10,% R11 is used as data storage, that is, the original value should be saved before using it.

Context switching is to temporarily save the registers of the CPU, and then mov the context registers of the running protocol to the corresponding registers. At this point, the context is switched. As shown in the following figure:

The code is as follows

_ _ asm__ (".text\ n".p2align 4 15\ n ".globl _ switch\ n" .globl _ switch\ n "_ switch:\ n"_ _ switch: \ n "" movq% rsp 0 (% rsi) # save stack_pointer\ n "" movq% rbp, 8 (% rsi) # save frame_pointer\ n "movq (% rsp),% rax # save insn_pointer\ n"movq% rax, 16 (% rsi)\ n"movq% rbx, 24 (% rsi) # save rbx R12-r15\ n "movq% R12,32 (% rsi)\ n"movq% R13,40 (% rsi)\ n"movq% R14,48 (% rsi)\ n"movq% R15" 56 (% rsi)\ n "" movq 56 (% rdi),% R15\ n "" movq 48 (% rdi),% R14\ n "" movq 40 (% rdi),% R13 # restore rbx,r12-r15\ n "movq 32 (% rdi) % R12\ n "" movq 24 (% rdi),% rbx\ n "" movq 8 (% rdi),% rbp # restore frame_pointer\ n "" movq 0 (% rdi),% rsp # restore stack_pointer\ n "movq 16 (% rdi) % rax # restore insn_pointer\ n "" movq% rax, (% rsp)\ n "" ret\ n ")

Scheduler of cooperative program

There are two schemes for the implementation of the scheduler, one is producer-consumer mode, the other is multi-state operation.

The logic code is as follows:

While (1) {/ / traverses the sleep set, adding those that meet the conditions to ready nty_coroutine * expired = NULL; while ((expired = sleep_tree_expired (sched))! =) {TAILQ_ADD (& sched- > ready, expired);} / traversing the waiting set, adding those that meet the requirements to ready nty_coroutine * wait = NULL Int nready = epoll_wait (sched- > epfd, events, EVENT_MAX, 1); for (I = 0

< nready;i ++) { wait = wait_tree_search(events[i].data.fd); TAILQ_ADD(&sched->

Ready, wait);} / use resume to reply to ready's co-operation right while (! TAILQ_EMPTY (& sched- > ready)) {nty_coroutine * ready = TAILQ_POP (sched- > ready); resume (ready);}}

Multi-state operation

The implementation logic code is as follows:

While (1) {/ / traverses the sleep set, uses resume to restore the cooperative running right of expired nty_coroutine * expired = NULL; while ((expired = sleep_tree_expired (sched))! =) {resume (expired);} / / traverses the waiting set, uses resume to restore the cooperative running right of wait nty_coroutine * wait = NULL Int nready = epoll_wait (sched- > epfd, events, EVENT_MAX, 1); for (I = 0

< nready;i ++) { wait = wait_tree_search(events[i].data.fd); resume(wait); } // 使用resume恢复ready的协程运行权 while (!TAILQ_EMPTY(sched->

Ready) {nty_coroutine * ready = TAILQ_POP (sched- > ready); resume (ready);}

Performance testing

Test environment: 4 VMWare virtual machines

1 server with 6 GB memory and 4 cores of CPU

3 clients have 2G memory and 2 core CPU

Operating system: ubuntu 14.04

Server-side test code: https://github.com/wangbojing/NtyCo

Client test code: https://github.com/wangbojing/c1000k_test/blob/master/client_mutlport_epoll.c

Start a co-program for each connection to test. The start-up number of the cooperative process can reach 70W without exception.

BAT, Didi, Jinri Toutiao, Meitu, Meituan and other front-line technical posts

QQ group: 935760465

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.