C++校招项目推荐：高性能协程+RPC项目，一个项目打通后端8大核心技术

# 如果使用VS Code/Cursor，直接打开项目，选择"Reopen in Container"
# DevContainer会自动安装所有依赖

# 下载protobuf 3.19.4
wget https://github.com/protocolbuffers/protobuf/releases/download/v3.19.4/protobuf-cpp-3.19.4.tar.gz
tar xzf protobuf-cpp-3.19.4.tar.gz
cd protobuf-3.19.4
./configure
make -j$(nproc)
sudo make install
sudo ldconfig

# 方式一：通过git克隆（推荐）
git clone git://git.code.sf.net/p/tinyxml/git tinyxml
cd tinyxml
​
# 编译所有源文件
make -j4
​
# 用ar命令将.o文件打包成静态库
ar cr libtinyxml.a *.o
​
# 安装库文件和头文件到系统路径
sudo cp libtinyxml.a /usr/lib/
sudo mkdir -p /usr/include/tinyxml
sudo cp *.h /usr/include/tinyxml
​
cd ..

cd tinyrpc
mkdir -p bin lib obj
​
# 生成protobuf桩文件
cd testcases
protoc --cpp_out=./ test_tinypb_server.proto
cd ..
​
# 编译（二选一）
# 方式一：makefile
make -j4
sudo make install
​
# 方式二：cmake
mkdir build
sudo ./build.sh

# 启动TinyPB RPC服务
cd bin
nohup ./test_tinypb_server ../conf/test_tinypb_server.xml &
​
# 验证服务是否启动
ps -elf | grep test_tinypb_server
netstat -tln | grep 20000
​
# 使用客户端访问服务端
./test_tinypb_server_client 
# 期望输出：Send to tinyrpc server 127.0.0.1:20000, requeset body: 
# 期望输出：Success get response frrom tinyrpc server 127.0.0.1:20000, response body: res_info: "OK" age: 100100111
​
​
# 启动HTTP服务
nohup ./test_http_server ../conf/test_http_server.xml &
​
# 测试HTTP接口
curl -X GET 'http://127.0.0.1:19999/qps?id=1'
# 期望输出：QPSHttpServlet Echo Success!! Your id is,1

# 安装wrk压测工具
git clone https://github.com/wg/wrk.git
cd wrk
make -j$(nproc)
sudo cp wrk /usr/local/bin/

# 确保HTTP服务已启动且关闭日志（提升性能）
# 在xml配置中设置rpc_log_level为NONE
​
# 基础测试：1000并发，持续30秒
wrk -c 1000 -t 8 -d 30 --latency 'http://127.0.0.1:19999/qps?id=1'
​
# 高压测试：5000并发
wrk -c 5000 -t 8 -d 30 --latency 'http://127.0.0.1:19999/qps?id=1'
​
# 极限测试：10000并发
wrk -c 10000 -t 8 -d 30 --latency 'http://127.0.0.1:19999/qps?id=1'

TinyRPC整体架构
​
┌───────────────────────────────────────────────────────────────┐
│                        应用层（用户代码）                      │
│  ┌───────────────┐  ┌──────────────┐  ┌──────────────┐        │
│  │ HTTP Servlet  │  │ RPC Service  │  │  RPC Client  │        │
│  └───────┬───────┘  └───────┬──────┘  └───────┬──────┘        │
├──────────┼──────────────────┼─────────────────┼───────────────┤
│                        RPC调用封装层                          │
│  ┌───────────────────────────────────────────────────────┐    │
│  │       TinyPbRpcChannel / TinyPbRpcAsyncChannel        │    │
│  └───────────────────────────────────────────────────────┘    │
├───────────────────────────────────────────────────────────────┤
│                        协议编解码层                           │
│  ┌───────────────┐      ┌───────────────────┐                 │
│  │   HTTP Codec  │      │    TinyPB Codec   │                 │
│  └───────────────┘      └───────────────────┘                 │
├───────────────────────────────────────────────────────────────┤
│                        网络传输层                             │
│  ┌─────────────────────────────────────────────────────┐     │
│  │       TcpServer / TcpConnection / TcpClient         │     │
│  └─────────────────────────────────────────────────────┘     │
├──────────────────────────────────────────────────────────────┤
│                       核心引擎层                              │
│  ┌───────────┐  ┌─────────────┐  ┌──────────────────┐        │
│  │  Reactor  │  │  Coroutine  │  │  Async Logger    │        │
│  │  (epoll)  │  │  (m:n模型)  │  │  (生产者-消费者)  │        │
│  └───────────┘  └─────────────┘  └──────────────────┘        │
└──────────────────────────────────────────────────────────────┘

tinyrpc/
├── comm/              # 公共工具：日志、配置、线程池
│   ├── log.h/cc       # 异步日志系统
│   ├── config.h/cc    # XML配置解析
│   └── ...
├── coroutine/         # 协程模块（★核心难点★）
│   ├── coroutine.h/cc        # 协程封装（Resume/Yield）
│   ├── coctx.h               # 协程上下文（14个寄存器）
│   ├── coctx_swap.S          # 汇编实现的上下文切换
│   ├── coroutine_hook.h/cc   # 系统调用Hook
│   ├── coroutine_pool.h/cc   # 协程池
│   └── memory.h/cc           # 协程栈内存管理
├── net/               # 网络模块
│   ├── reactor.h/cc   # Reactor事件循环
│   ├── fd_event.h/cc  # 文件描述符事件封装
│   ├── timer.h/cc     # 定时器
│   ├── tcp/           # TCP模块
│   │   ├── tcp_server.h/cc       # TCP服务端
│   │   ├── tcp_connection.h/cc   # TCP连接管理
│   │   ├── io_thread.h/cc        # IO线程及线程池
│   │   └── ...
│   ├── http/          # HTTP协议模块
│   │   ├── http_codec.h/cc       # HTTP编解码
│   │   ├── http_servlet.h/cc     # Servlet接口
│   │   └── ...
│   └── tinypb/        # TinyPB自定义协议模块
│       ├── tinypb_codec.h/cc     # TinyPB编解码
│       ├── tinypb_rpc_channel.h/cc       # 阻塞式RPC调用
│       ├── tinypb_rpc_async_channel.h/cc # 非阻塞式RPC调用
│       └── ...
├── testcases/         # 测试用例
├── conf/              # 配置文件
└── generator/         # 代码生成脚手架

// tinyrpc/coroutine/coctx.h
struct coctx {
  void* regs[14];   // 14个寄存器的"快照"
};
​
enum {
  kRBP = 6,       // 栈底指针
  kRDI = 7,       // 第一个参数
  kRSI = 8,       // 第二个参数
  kRETAddr = 9,   // 返回地址（即下次从哪继续执行）
  kRSP = 13,      // 栈顶指针
};

regs[14] 数组内存布局（每格8字节，总共112字节）
┌──────────┬──────────┬──────────┬──────────┬──────────┬──────────┬──────────┐
│ regs[0]  │ regs[1]  │ regs[2]  │ regs[3]  │ regs[4]  │ regs[5]  │ regs[6]  │
│  r15     │  r14     │  r13     │  r12     │   r9     │   r8     │  rbp     │
│ 偏移 0   │ 偏移 8   │ 偏移 16   │ 偏移 24  │ 偏移 32  │ 偏移 40  │ 偏移 48  │
├──────────┼──────────┼──────────┼──────────┼──────────┼──────────┼──────────┤
│ regs[7]  │ regs[8]  │ regs[9]  │ regs[10] │ regs[11] │ regs[12] │ regs[13] │
│  rdi     │  rsi     │ retAddr  │  rdx     │  rcx     │  rbx     │  rsp     │
│ 偏移 56  │ 偏移 64  │  偏移 72  │ 偏移 80  │ 偏移 88  │ 偏移 96  │ 偏移 104 │
└──────────┴──────────┴──────────┴──────────┴──────────┴──────────┴──────────┘
​
汇编里 "movq %rax, 104(%rdi)" → 104 = kRSP(13) × 8
汇编里 "movq %rbp, 48(%rdi)"  →  48 = kRBP(6)  × 8
所有偏移量都是 数组下标 × 8字节 算出来的，没有魔法。

; tinyrpc/coroutine/coctx_swap.S——来自腾讯libco
coctx_swap:
    ; ===== 第一阶段：保存当前协程的寄存器 =====
    ; rdi指向当前协程的coctx（第一个参数）
    
    leaq (%rsp),%rax        ; 把当前栈顶地址存到rax
    movq %rax, 104(%rdi)    ; 保存rsp（regs[13]）
    movq %rbx, 96(%rdi)     ; 保存rbx（regs[12]）
    movq %rcx, 88(%rdi)     ; 保存rcx（regs[11]）
    ; ... 保存其他寄存器 ...
    movq %rbp, 48(%rdi)     ; 保存rbp（regs[6]）
    
    ; ===== 第二阶段：恢复目标协程的寄存器 =====
    ; rsi指向目标协程的coctx（第二个参数）
    
    movq 48(%rsi), %rbp     ; 恢复rbp
    movq 104(%rsi), %rsp    ; 恢复rsp（栈切换！）
    ; ... 恢复其他寄存器 ...
    
    leaq 8(%rsp), %rsp      ; 调整栈顶
    pushq 72(%rsi)          ; 把返回地址压栈
    movq 64(%rsi), %rsi     ; 恢复rsi
    ret                     ; ret指令会跳转到栈顶地址执行

第①步：leaq 8(%rsp), %rsp
  rsp += 8，跳过栈上旧的返回地址（我们不要它）
​
  ┌────────────────────────┐
  │ ...上层栈帧...         │  ← rsp 现在指向这里
  ├────────────────────────┤
  │ 旧的返回地址（已跳过）  │
  └────────────────────────┘
​
第②步：pushq 72(%rsi)
  72 = kRETAddr(9) × 8，即coctx里保存的返回地址
  pushq = rsp减8，把值写到栈顶
​
  ┌────────────────────────┐
  │ ...上层栈帧...         │
  ├────────────────────────┤
  │ regs[9]的返回地址      │  ← rsp 指向这里（新压入的）
  └────────────────────────┘
​
第③步：ret
  ret = pop栈顶 → rip，CPU跳转到regs[9]保存的地址继续执行
  也就是目标协程上次Yield时的下一条指令
​
效果：用coctx里的返回地址替换了栈上的旧地址，ret跳转过去。切换完成。

Resume（唤醒）: 主协程 → 目标协程   "老板说：你去干活"
Yield（让出）:  目标协程 → 主协程   "打工人说：我干不动了，先歇会"

// 从主协程切换到目标协程
void Coroutine::Resume(Coroutine* co) {
    // 安全检查：只有主协程才能Resume其他协程
    if (t_cur_coroutine != t_main_coroutine) {
        return;  // 必须由"老板"来分配任务
    }
    t_cur_coroutine = co;  // 标记当前执行的协程
    coctx_swap(&(t_main_coroutine->m_coctx), &(co->m_coctx));
    //          ↑ 保存主协程状态              ↑ 恢复目标协程状态
}
​
// 从目标协程切换回主协程
void Coroutine::Yield() {
    Coroutine* co = t_cur_coroutine;
    t_cur_coroutine = t_main_coroutine;  // 切回主协程
    coctx_swap(&(co->m_coctx), &(t_main_coroutine->m_coctx));
    //          ↑ 保存当前协程状态           ↑ 恢复主协程状态
}

// 原理：利用dlsym获取原始系统调用的地址
#define HOOK_SYS_FUNC(name) \
    name##_fun_ptr_t g_sys_##name##_fun = (name##_fun_ptr_t)dlsym(RTLD_NEXT, #name);
​
HOOK_SYS_FUNC(read);   // g_sys_read_fun指向真正的read系统调用
HOOK_SYS_FUNC(write);
HOOK_SYS_FUNC(connect);
HOOK_SYS_FUNC(accept);
HOOK_SYS_FUNC(sleep);

// tinyrpc/coroutine/coroutine_hook.cc 第66-108行
ssize_t read_hook(int fd, void *buf, size_t count) {
    // ① 主协程检查——主协程不能Yield，直接走原版
    if (Coroutine::IsMainCoroutine()) return g_sys_read_fun(fd, buf, count);
​
    // ② 设为非阻塞——Hook的前提是非阻塞IO
    fd_event->setNonBlock();
​
    // ③ 先尝试直接读
    ssize_t n = g_sys_read_fun(fd, buf, count);
    if (n > 0) return n;   // 有数据就直接返回
​
    // ④ 没数据（EAGAIN），注册epoll监听
    toEpoll(fd_event, READ);
​
    // ⑤ 让出协程，切回主协程
    Coroutine::Yield();
​
    // ⑥ 被Resume唤醒，取消epoll监听
    fd_event->delListenEvents(READ);
    fd_event->clearCoroutine();
​
    // ⑦ 真正读数据
    return g_sys_read_fun(fd, buf, count);
}

  用户代码               read_hook()                 epoll/Reactor              网络
    │                       │                           │                     │
    │  read(fd,buf,n)       │                           │                     │
    │─────────────────────→ │                           │                     │
    │                       │  setNonBlock              │                     │
    │                       │  g_sys_read_fun()         │                     │
    │                       │  返回EAGAIN               │                     │
    │                       │                           │                     │
    │                       │  toEpoll(fd,READ)  ──→    │  注册fd可读监听     │
    │                       │  Coroutine::Yield()──→    │                     │
    │                       │  ┌────────────────┐       │                     │
    │                       │  │ 协程A被挂起    │       │                     │
    │                       │  │ CPU去处理      │       │                     │
    │                       │  │ 其他协程B,C..  │       │                     │
    │                       │  └────────────────┘       │                     │
    │                       │                           │ ←── 数据到达 ──│
    │                       │                           │  epoll_wait返回     │
    │                       │ ←──── Resume(协程A) ──────│                     │
    │                       │  delListenEvents          │                     │
    │                       │  g_sys_read_fun() ──────→ │                     │
    │                       │  返回n字节                │                     │
    │  ←───── 返回n ─────── │                           │                     │
    │  继续执行...          │                           │                     │
​
用户代码只看到：调了read()→拿到了数据。完全感知不到中间的Yield/Resume。

// tinyrpc/coroutine/coroutine_hook.cc 第191-263行（简化）
int connect_hook(int sockfd, const struct sockaddr *addr, socklen_t addrlen) {
    fd_event->setNonBlock();
    int n = g_sys_connect_fun(sockfd, addr, addrlen);
    if (n == 0) return 0;              // 立即连上
    if (errno != EINPROGRESS) return n; // 真的失败
​
    toEpoll(fd_event, WRITE);           // 连接完成时fd变为可写
​
    // 同时注册超时定时器
    bool is_timeout = false;
    auto timeout_cb = [&is_timeout, cur_cor]() {
        is_timeout = true;
        Coroutine::Resume(cur_cor);     // 超时也唤醒协程
    };
    timer->addTimerEvent(timeout_event);
​
    Coroutine::Yield();                 // 等连接完成或超时
​
    // 唤醒后用is_timeout区分原因
    timer->delTimerEvent(timeout_event); // 清理定时器
    if (is_timeout) { errno = ETIMEDOUT; return -1; }
    return 0;
}

======= 1:n模型 =======
​
IO线程1: [epoll] → Resume(C1) → Resume(C2) → Resume(C3)
                                               ↑ C3很慢，C1/C2被堵
IO线程2: [epoll] → Resume(C4)                  ← 很闲，帮不上忙
IO线程3: [epoll] → Resume(C5)                  ← 很闲，帮不上忙
​
问题：C3阻塞了IO线程1上的所有协程，线程2和3干瞪眼。
​
​
======= m:n模型 =======
​
全局队列: [C1, C2, C3, C4, C5]
​
IO线程1: pop→C1→处理完→pop→C3→C3很慢→Yield→C3回到队列
IO线程2: pop→C2→处理完→pop→C4→处理完→pop→C3→继续C3的工作
IO线程3: pop→C5→处理完→队列空了→epoll_wait等新事件
​
结果：C3很慢？没关系，它Yield后回到队列，
      IO线程2有空了就接着处理。没有任何线程被堵死。

// 全局协程任务队列，所有IO线程共享
// tinyrpc/net/reactor.h 第124-135行
class CoroutineTaskQueue {
    std::queue<FdEvent*> m_task;
    Mutex m_mutex;    // 多线程共享，必须加锁
};
​
// Reactor事件循环中，SubReactor从全局队列取协程执行
// tinyrpc/net/reactor.cc 第233-244行
if (m_reactor_type != MainReactor) {
    while (1) {
        FdEvent* ptr = CoroutineTaskQueue::GetCoroutineTaskQueue()->pop();
        if (ptr) {
            ptr->setReactor(this);                  // ★ 关键：更新Reactor指针
            Coroutine::Resume(ptr->getCoroutine());
        } else {
            break;
        }
    }
}

// tinyrpc/net/reactor.cc 第294-304行
if (ptr->getCoroutine()) {
    if (!first_coroutine) {
        first_coroutine = ptr->getCoroutine();  // 第一个就绪协程不入队
        continue;
    }
    CoroutineTaskQueue::GetCoroutineTaskQueue()->push(ptr);  // 其余入全局队列
}
​
// 循环开头直接Resume
if (first_coroutine) {
    Coroutine::Resume(first_coroutine);  // 省掉push+pop各一次锁操作
    first_coroutine = NULL;
}

每个请求到来：
  ① 分配128KB栈内存              ← 内核需要建立虚拟地址映射
  ② new Coroutine对象            ← 堆分配
  ③ setCallBack初始化coctx        ← 纯计算，很快
  ④ 执行业务...
请求处理完：
  ⑤ 释放128KB栈内存              ← 归还内存
  ⑥ delete Coroutine对象         ← 堆释放
​
14万QPS = 每秒执行14万次 ①②⑤⑥ = CPU全在做内存管理

初始化阶段（只做一次）：
  Memory一次性分配 pool_size × 128KB
  第一轮使用触发缺页，之后物理页就一直在了
​
运行阶段（每个请求）：
  ① getCoroutineInstanse() 从数组取一个   ← O(N)遍历，纯用户态
  ② setCallBack重置coctx                  ← 纯计算
  ③ 执行业务...
  ④ returnCoroutine() 标记为空闲           ← 改一个bool
​
  没有内存分配/释放，没有缺页中断

// tinyrpc/coroutine/coroutine_pool.cc 第46-73行
Coroutine::ptr CoroutinePool::getCoroutineInstanse() {
    Mutex::Lock lock(m_mutex);   // m:n模型下多线程共享，必须加锁
    for (int i = 0; i < m_pool_size; ++i) {
        if (!m_free_cors[i].first->getIsInCoFunc() && !m_free_cors[i].second) {
            m_free_cors[i].second = true;
            Coroutine::ptr cor = m_free_cors[i].first;
            lock.unlock();
            return cor;
        }
    }
    // 池中没有可用协程，扩容
    m_memory_pool.push_back(std::make_shared<Memory>(m_stack_size, m_pool_size));
    return std::make_shared<Coroutine>(m_stack_size, m_memory_pool.back()->getBlock());
}

                    ┌──────────────────┐
                    │   MainReactor    │
                    │  (主线程)        │
                    │  职责：accept    │
                    │  新连接          │
                    └─────────┬────────┘
                              │ 分发新连接
              ┌───────────────┼──────────────┐
              ▼               ▼              ▼
     ┌────────────┐  ┌────────────┐  ┌────────────┐
     │ SubReactor │  │ SubReactor │  │ SubReactor │
     │  IO线程1   │  │  IO线程2   │  │  IO线程3   │
     │ epoll_wait │  │ epoll_wait │  │ epoll_wait │
     │ 处理读写   │  │ 处理读写   │  │ 处理读写    │
     └────────────┘  └────────────┘  └────────────┘
           ↕                ↕              ↕
    ┌─────────────────────────────────────────────────┐
    │           全局协程任务队列（加锁）               │
    │      协程A  协程B  协程C  协程D  ...             │
    └─────────────────────────────────────────────────┘

Reactor::loop() 单次循环：
​
 ① 从全局队列pop就绪协程并Resume（仅SubReactor）
    → 配合m:n模型，从CoroutineTaskQueue取其他线程投递的协程
    → 注意：pop后要setReactor(this)更新Reactor指针
​
 ② 执行pending_tasks
    → 其他线程投递的异步任务（如注册新fd），先放进队列，这里统一执行
​
 ③ epoll_wait等待事件
    → 阻塞直到有IO事件就绪、定时器到期、或被wakeup唤醒
​
 ④ 事件分发
    → wakeup fd → 读掉eventfd的数据
    → timer fd → 直接执行定时回调
    → 有关联协程 → 第一个直接Resume（first_coroutine优化），后续入全局队列
    → 有回调函数 → 放入pending_tasks
​
 ⑤ 处理跨线程投递的fd添加/删除
    → 将pending_add_fds和pending_del_fds统一应用到epoll

// 创建（tinyrpc/net/reactor.cc 第52行）
m_wake_fd = eventfd(0, EFD_NONBLOCK);
​
// 唤醒（tinyrpc/net/reactor.cc 第122-133行）
void Reactor::wakeup() {
    if (!m_is_looping) return;
    uint64_t tmp = 1;
    g_sys_write_fun(m_wake_fd, &tmp, 8);  // 往eventfd写个1
}

1. 创建IOThreadPool（N个IO线程，每个线程一个SubReactor）
2. 创建MainReactor
3. 创建accept协程，绑定MainAcceptCorFunc
4. Resume accept协程 → 开始监听新连接
5. 启动所有IO线程（sem_post）
6. MainReactor进入loop
​
MainAcceptCorFunc循环：
  └→ accept（hook版）→ 无新连接则Yield
  └→ 有新连接 → 创建TcpConnection → 分配到某个IO线程
  └→ 将连接的协程加入该IO线程的Reactor

┌────────┬────────┬──────────────┬──────────────┬──────────────────┬──────────┬─────────────┬──────────┬──────────┬────────────┬──────┐
│ start  │ pk_len │ msg_req_len  │   msg_req    │ service_name_len │ service  │  err_code   │ err_info │ pb_data  │ check_num  │ end  │
│ 0x02   │  4B    │     4B       │   变长       │       4B         │  变长    │     4B      │    变长   │  变长    │    4B      │0x03  │
└────────┴────────┴──────────────┴──────────────┴──────────────────┴──────────┴─────────────┴──────────┴──────────┴────────────┴──────┘

生产者（多个IO线程）            消费者（日志线程）
    │                                 │
    ├─ pushRpcLog(msg) ──→ buffer │
    ├─ pushAppLog(msg) ──→ buffer │
    │                                 │ 定时flush
    │                                 ├──→ 写入RPC日志文件
    │                                 └──→ 写入APP日志文件

top = reinterpret_cast<char*>((reinterpret_cast<unsigned long>(top)) & -16LL);

m_coctx.regs[kRETAddr] = reinterpret_cast<char*>(CoFunction);
m_coctx.regs[kRDI] = reinterpret_cast<char*>(this);  // CoFunction的参数

void CoFunction(Coroutine* co) {
    co->m_call_back();    // 执行用户回调
    Coroutine::Yield();   // 回调结束后必须让出，否则CPU会执行到非法地址
}

// 超时回调和epoll回调都可能Resume协程
// 必须用is_timeout标志区分唤醒原因
auto timeout_cb = [&is_timeout, cur_cor]() {
    is_timeout = true;
    Coroutine::Resume(cur_cor);
};

// 这些对象在线程A创建，在线程B的新协程中使用
std::shared_ptr<queryAgeReq> rpc_req = std::make_shared<queryAgeReq>();
std::shared_ptr<queryAgeRes> rpc_res = std::make_shared<queryAgeRes>();
​
// 必须调用saveCallee预留引用计数！
// 否则rpc_req/rpc_res可能在函数返回后被析构，线程B访问就coredump
async_channel->saveCallee(rpc_controller, rpc_req, rpc_res, closure);