1
// Linux task_struct 简化模型
2
struct task_struct {
3
    // ========== 标识信息 ==========
4
    pid_t pid;                      // 进程 ID
5
    pid_t tgid;                     // 线程组 ID（= 主线程的 pid）
6

7
    // ========== 状态信息 ==========
8
    volatile long state;            // TASK_RUNNING / TASK_INTERRUPTIBLE / ...
9
    int exit_state;                 // EXIT_ZOMBIE / EXIT_DEAD
10
    unsigned int flags;             // PF_EXITING / PF_KTHREAD / ...
11

12
    // ========== 调度信息 ==========
13
    int prio;                       // 动态优先级
14
    int static_prio;                // 静态优先级（nice 值映射）
15
    int normal_prio;                // 归一化优先级
16
    struct sched_entity se;         // CFS 调度实体（含 vruntime）
17

18
    // ========== CPU 上下文 ==========
19
    struct thread_struct thread;    // 寄存器上下文（SP、IP、通用寄存器...）
20

21
    // ========== 内存管理 ==========
22
    struct mm_struct *mm;           // 内存描述符（页表、VMA 链表...）
23
                                    // 线程间共享同一个 mm_struct！
24

25
    // ========== 文件系统 ==========
26
    struct files_struct *files;     // 打开的文件描述符表
27
    struct fs_struct *fs;           // 文件系统信息（pwd、根目录）
28

29
    // ========== 信号 ==========
30
    struct signal_struct *signal;   // 信号处理相关
31
    sigset_t blocked;               // 被阻塞的信号集
32

33
    // ========== 家族关系 ==========
34
    struct task_struct *parent;     // 父进程
35
    struct list_head children;      // 子进程链表
36
    struct list_head sibling;       // 兄弟进程链表
37
};

1
#include <functional>
2
#include <atomic>
3
#include <vector>
4
#include <thread>
5

6
// Job 定义
7
struct Job {
8
    std::function<void()> task;       // 要执行的任务
9
    std::atomic<int> unfinished_jobs; // 未完成的子任务计数
10
    Job* parent;                      // 父任务（完成时通知）
11
};
12

13
// 简化版 Job System（完整版参见 C++ Ch7 线程池）
14
class JobSystem {
15
    static constexpr int MAX_JOBS = 4096;
16

17
    // 每个 Worker 线程有自己的 Job 队列（减少锁竞争）
18
    struct WorkerQueue {
19
        Job jobs[MAX_JOBS];
20
        std::atomic<int> head{0};
21
        std::atomic<int> tail{0};
22

23
        void push(const Job& job) {
24
            int t = tail.load(std::memory_order_relaxed);
25
            jobs[t % MAX_JOBS] = job;
26
            tail.store(t + 1, std::memory_order_release);
27
        }
28

29
        bool pop(Job& job) {
30
            int h = head.load(std::memory_order_relaxed);
31
            if (h >= tail.load(std::memory_order_acquire)) return false;
32
            job = jobs[h % MAX_JOBS];
33
            head.store(h + 1, std::memory_order_release);
34
            return true;
35
        }
36
    };
37

38
    std::vector<std::thread> _workers;
39
    std::vector<WorkerQueue> _queues;
40
    std::atomic<bool> _running{true};
41
    int _num_workers;
42

43
public:
44
    JobSystem()
45
        : _num_workers(std::thread::hardware_concurrency() - 1) // 留一个核给主线程
46
    {
47
        _queues.resize(_num_workers);
48
        for (int i = 0; i < _num_workers; ++i) {
49
            _workers.emplace_back([this, i]() {
50
                while (_running.load(std::memory_order_relaxed)) {
51
                    Job job;
52
                    // 先从自己的队列取
53
                    if (_queues[i].pop(job)) {
54
                        job.task();
55
                    } else {
56
                        // 自己队列空了 → work stealing：从其他线程的队列偷
57
                        bool stolen = false;
58
                        for (int j = 0; j < _num_workers && !stolen; ++j) {
59
                            if (j != i && _queues[j].pop(job)) {
60
                                job.task();
61
                                stolen = true;
62
                            }
63
                        }
64
                        if (!stolen) {
65
                            std::this_thread::yield();  // 都空了，让出 CPU
66
                        }
67
                    }
68
                }
69
            });
70
        }
71
    }
72

73
    // 提交 Job
74
    void submit(std::function<void()> task) {
75
        static std::atomic<int> round_robin{0};
76
        int idx = round_robin.fetch_add(1) % _num_workers;
77
        Job job;
78
        job.task = std::move(task);
79
        _queues[idx].push(job);
80
    }
81

82
    ~JobSystem() {
83
        _running.store(false);
84
        for (auto& w : _workers) w.join();
85
    }
86
};

1
JobSystem jobs;
2

3
void GameFrame() {
4
    // 并行更新物理（按区块拆分）
5
    for (int chunk = 0; chunk < num_chunks; ++chunk) {
6
        jobs.submit([chunk]() {
7
            updatePhysicsChunk(chunk);
8
        });
9
    }
10

11
    // 并行更新 AI
12
    for (auto& entity : entities_with_ai) {
13
        jobs.submit([&entity]() {
14
            entity.ai->tick();
15
        });
16
    }
17

18
    // 并行计算动画
19
    for (auto& anim : active_animations) {
20
        jobs.submit([&anim]() {
21
            anim.evaluate(current_time);
22
        });
23
    }
24

25
    // 注意：实际引擎中需要等待所有 Job 完成后再继续
26
    // 这里省略了同步机制（CountdownLatch / Atomic Counter）
27
}

1
// 将线程绑定到特定 CPU 核心 → 减少缓存污染
2

3
// Linux
4
#include <pthread.h>
5
void setThreadAffinity(std::thread& t, int core_id) {
6
    cpu_set_t cpuset;
7
    CPU_ZERO(&cpuset);
8
    CPU_SET(core_id, &cpuset);
9
    pthread_setaffinity_np(t.native_handle(), sizeof(cpu_set_t), &cpuset);
10
}
11

12
// Windows
13
#include <windows.h>
14
void setThreadAffinity(HANDLE thread, int core_id) {
15
    SetThreadAffinityMask(thread, 1ULL << core_id);
16
}