在完成claude的安装之后，本文基于claude的简单命令进行介绍，用来进一步了解claude的基本使用技巧

# login
我们有两种办法登录，一个是订阅pro/max方法的登录，一个是apikey的登录。

关于apikey的登录上一个文章已经介绍了。这里介绍订阅的办法。

首先需要能够正常访问claude.ai，如下

![image.png](/static/img/9daaabb0eb60e1edf01615b582aff17e.image.webp)

如果不能访问此网站，需要做如下两个事情
* 你所在是不支持的国家
* 没有能够登录claude.ai的账号

如果登入进去之后，可以看到付费情况

![image.png](/static/img/df337df5ac33d184303a63295507a14e.image.webp)

此时我们需要手机付款，手机付款需要满足如下条件
* 非中国区域apple账号/android账号
* 支付宝购买礼品卡
* 购买pro/max会员

上面都完成了之后，首次登录需要login，此时敲入`/login`后信息如下

![image.png](/static/img/a8022275a5def4b8fe00c409a202f8ba.image.webp)

此时选择第一个 subscription 即可。然后在浏览器的url上成功验证登录即可

当login完成之后，

```
# claude
  ▐▛███▜▌   Claude Code v2.1.83
▝▜█████▛▘  Sonnet 4.6 · Claude Pro
  ▘▘ ▝▝    ~/
```
可以看到，claude pro订阅会员已经正常了。

# init
在一个仓库上进行自动分析代码和文本的时候，可以先尝试init进行分析。这样可以在本地创建记忆文件CLAUDE.md，下次再加载的时候，不需要重复学习
```
● Explore(Explore codebase structure)
  ⎿  Done (8 tool uses · 28.4k tokens · 28s)
  (ctrl+o to expand)

● Write(CLAUDE.md)
  ⎿  Wrote 33 lines to CLAUDE.md
     # CLAUDE.md

     This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.

     ## Running the Server

     ```bash
     # Default upload directory (./uploads)
     python3 run.py

     … +23 lines (ctrl+o to expand)

● Created CLAUDE.md. It covers:
  - How to run the server (with default and custom upload dir)
  - The single-file architecture and key components
  - Security measures already implemented

✻ Sautéed for 51s

```
可以看到claude会自动分析，探索当前目录的下的一切内容，最终生成一份记忆给你
# memory
可以针对当前项目自动生成的`CLAUDE.md`进行自我改造，调整记忆中和你认为偏差的地方
```
❯ /memory

─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
  Memory

    Auto-memory: on
    Auto-dream: off · never

  ❯ 1. Project memory           Saved in ./CLAUDE.md
    2. User memory              Saved in ~/.claude/CLAUDE.md
    3. Open auto-memory folder

  Learn more: https://code.claude.com/docs/en/memory
```
此时可以随时修改 当前目录/当前用户/自动记忆 三个地方的记忆

# permissions
管理权限，默认情况下每次write和select都会提醒你选择，你可以管理你的权限，如下
```
❯ /permissions

─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
  Permissions:  Allow   Ask   Deny   Workspace

  Claude Code can read files in the workspace, and make edits when auto-accept edits is on.

    -  ~/fileupload (Original working directory)
    1. Add directory…
```
当前，也可以管理claude接管的所有目录，当你涉及的目录很多的时候，可以直接通过此命令管理
# context
不同的模型可拥有的上下文长度不一样，可以实时的查看自己用了多少的上下文，如下
```
❯ /context
  ⎿  Context Usage
     ⛁ ⛁ ⛁ ⛁ ⛁ ⛁ ⛁ ⛀ ⛀ ⛁   claude-sonnet-4-6 · 20k/200k tokens (10%)
     ⛁ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶
     ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶   Estimated usage by category
     ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶   ⛁ System prompt: 6.9k tokens (3.4%)
     ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶   ⛁ System tools: 8.1k tokens (4.0%)
     ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶   ⛁ Memory files: 346 tokens (0.2%)
     ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶   ⛁ Skills: 776 tokens (0.4%)
     ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶   ⛁ Messages: 4.3k tokens (2.1%)
     ⛶ ⛶ ⛶ ⛝ ⛝ ⛝ ⛝ ⛝ ⛝ ⛝   ⛶ Free space: 147k (73.3%)
     ⛝ ⛝ ⛝ ⛝ ⛝ ⛝ ⛝ ⛝ ⛝ ⛝   ⛝ Autocompact buffer: 33k tokens (16.5%)
```
可以看到，我这里总共200k的上下文使用了20k上下文。并且提供了tokens的分类。
# clear
如果一次问答完成，可以清空上下文，让claude给你干下一份工作
```
❯ /clear
  ⎿  (no content)

❯ /context
  ⎿  Context Usage
     ⛁ ⛁ ⛁ ⛁ ⛁ ⛁ ⛁ ⛀ ⛀ ⛀   claude-sonnet-4-6 · 16k/200k tokens (8%)
     ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶
     ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶   Estimated usage by category
     ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶   ⛁ System prompt: 6.9k tokens (3.4%)
     ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶   ⛁ System tools: 8.1k tokens (4.0%)
     ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶   ⛁ Memory files: 346 tokens (0.2%)
     ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶   ⛁ Skills: 776 tokens (0.4%)
     ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶   ⛁ Messages: 110 tokens (0.1%)
     ⛶ ⛶ ⛶ ⛝ ⛝ ⛝ ⛝ ⛝ ⛝ ⛝   ⛶ Free space: 151k (75.4%)
     ⛝ ⛝ ⛝ ⛝ ⛝ ⛝ ⛝ ⛝ ⛝ ⛝   ⛝ Autocompact buffer: 33k tokens (16.5%)
```
这里可以看到，我clear之后并没有清空我的上下文，主要原因是我自己安装了agent，skill，plugin，mcp，这些东西的description会占用我的上下文。

也就是说，如果你真的很少用到这些skill，清空你的skill是你最佳选择

# effort
我们可以随时调整claude的推理等级（low/medium/high/max），通过effort可以看到当前的推理等级
```
❯ /effort
  ⎿  Effort level: auto (currently medium)
```
# model
同样也可以在里面选择模型，订阅用户可以有如下选项自行选择
```
❯ /model

─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
  Select model
  Switch between Claude models. Applies to this session and future Claude Code sessions. For other/previous model names, specify with --model.

  ❯ 1. Default (recommended) ✔  Sonnet 4.6 · Best for everyday tasks
    2. Opus                     Opus 4.6 · Most capable for complex work
    3. Haiku                    Haiku 4.5 · Fastest for quick answers

  ◐ Medium effort (default) ← → to adjust
```
默认情况下Opus更聪明，我们可以选择Opus
# resume
默认情况下，每次我们打开一个claude的时候都重新创建了一次会话，而实际在使用过程中，我们经常期望接着之前的工作继续做，所以可以使用resume唤醒之前的会话
```
Resume Session
╭───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ ⌕ Search…                                                                                                                                                                                                                                 │
╰───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯

❯ /init
  1 hour ago · HEAD · 74.2KB

  Ctrl+A to show all projects · Ctrl+B to toggle branch · Ctrl+V to preview · Ctrl+R to rename · Type to search · Esc to cancel ·

```
正常情况下这里会提供之前使用的所有会话。除非你手动clear过

# 其他基本命令

```
/help	显示帮助信息及可用命令列表
/model	切换或查看当前使用的 AI 模型
/cost	显示当前会话的 Token 使用量和预估费用
/stats	显示当前会话的详细统计数据（如请求次数、Token 消耗等）
/clear	清除终端屏幕上的对话内容
/reset	重置当前对话上下文（清空历史记录，重新开始）
/undo	撤销上一步对文件进行的更改
/retry	重新运行上一个请求
/compact	压缩对话上下文以节省 Token 空间
/config	查看或修改 Claude Code 的配置（如设置、忽略规则等）
/bug	报告错误或向 Anthropic 提供反馈
/init	在当前目录初始化 Claude Code 配置
/exit	退出当前 Claude Code 会话
/resume	切换到其他会话
/rename	重命名当前会话
/memory	查看/编辑 CLAUDE.md 和自动记忆
/permissions	查看/管理权限规则
/hooks	浏览已配置的 Hooks
/agents	创建/管理子代理
/commit	创建 Git 提交
/context	检查上下文窗口使用情况
/effort	设置推理努力等级（low/medium/high/max）
/vim	切换 Vim 编辑模式
/theme	更换终端主题
/terminal-setup	配置终端功能
/statusline	设置状态栏显示
/desktop	发送会话到桌面应用
/teleport	拉取 Web 会话到终端
/btw	快速旁问（不影响对话历史）
```
当然，这里还有三个很重要的命令，后续会逐一介绍，分别为
```
/branch  为此刻创建分支，让你思维存在分支
/rewind  主动移除之前错误的对话
/btw     问一些无关当前探索的问题，不污染当前上下文
```
# 总结
本文介绍了claude的基本命令使用技巧，掌握这些基本命令就可以进行claude的基础使用了。接下来以一个实际的例子来演示claude的基础使用

AI使用指南(2)-基本命令使用

本文介绍ubuntu2404上的opengrok搭建步骤，opengrok是专用于大型代码查看的工具。通过ctags支持源码搜索。本步骤涉及的安装组件有三个： opengrok，tomcat，ctags

# tomcat
```
apt install -y tomcat10
```
如果没有java的话，安装一下java
```
apt install openjdk-21-jdk
```
此时重启tomcat10可以看到服务应该正常
```
systemctl restart tomcat10
```
网页登录后看到如下画面即可

![image.png](/static/img/c9ba51f03fcf46a0293b1a127ec5b968.image.webp)

# ctags
下载代码和安装
```
    $ git clone https://github.com/universal-ctags/ctags.git
    $ cd ctags
    $ ./autogen.sh
    $ ./configure  # use --prefix=/where/you/want to override installation directory, defaults to /usr/local
    $ make
    $ make install # may require extra privileges depending on where to install
```
# opengrok
我们先找到最新的opengrok的release

![image.png](/static/img/fc80ae1f0eb012495661e6e081e6a65e.image.webp)

此时拉取release bin即可
```
wget https://github.com/oracle/opengrok/releases/download/1.14.11/opengrok-1.14.11.tar.gz
```
将其解压
```
tar xvzf opengrok-1.14.11.tar.gz
```
然后找到安装python管理工具
```
python3 -m pip install tools/opengrok-tools.tar.gz
```
创建工作目录
```
export OPENGROK_HOME=/root/work/opengrok/opengrok-1.14.11
mkdir OPENGROK_HOME/{src,data,dist,etc,log}
```
复制war包给tomcat
```
cp $OPENGROK_HOME/lib/source.war /var/lib/tomcat10/webapps/
```
修改tomcat的端口，这里以22222端口为例
```
vim /etc/tomcat10/server.xml
    <Connector port="22222" protocol="HTTP/1.1"
               connectionTimeout="20000"
               redirectPort="8443"
               maxParameterCount="1000"
               />

```
再次重启tomcat
```
systemctl restart tomcat10
```
我们22222端口能进入即可，此时进入`localhost:22222/source`可以看到初始化页面如下

![image.png](/static/img/29eec98f73a4e09e4621f303eef80738.image.webp)

注意，此时没有Repository和Project

# index
接下来就是索引代码仓库了，因为我需要反复阅读内核代码，所以索引内核源码，如下
```
ln -sf path/to/kernel $OPENGROK_HOME/src/kernel
```
这样我们开始index，index的脚本如下
```
export OPENGROK_HOME=/root/work/opengrok/opengrok-1.14.11

java -Xmx16g \
    -Djava.util.logging.config.file=${OPENGROK_HOME}/doc/logging.properties \
    -jar ${OPENGROK_HOME}/lib/opengrok.jar \
    -c /usr/local/bin/ctags \
    -s ${OPENGROK_HOME}/src/ -d ${OPENGROK_HOME}/data -P -S -G \
    -W ${OPENGROK_HOME}/etc/configuration.xml -U http://localhost:22222/source
```
注意，如果需要索引git commit信息，那么加上`-H`，不过会浪费内存。

因为我是mainline kernel，commit message实在太多，索引不了，所以没有`-H`

这里索引会大概1-2小时，等待结束即可

# 最终效果
当索引完成之后，我们直接登入`localhost:22222/source`再看

![image.png](/static/img/d8bb24510f0cbc55ae354c3d2cfffa22.image.webp)

可以看到有kernel仓库了，我们直接找关键函数，例如`scheduler_tick`,直接找到信息如下

![image.png](/static/img/e5397f7e8939d8fcb0ad61ed1a3e9fdc.image.webp)

可以看到，准确找到了sched/core.c的位置

# 参考
> https://github.com/oracle/opengrok/wiki/How-to-setup-OpenGrok


opengrok搭建

今年26年一开始，工作性质就来了王炸，claude在工作的高效使用使得绝大部分专业人士都在推崇ai。当然，最近还有另一个东西很火，那就是openclaw，我也把openclaw搭建在自己的服务器上。可是我个人观点是，对于专业技术行业，我们更需要的是claude，而不是openclaw。

对于claude还是openclaw我们可以思考一下，我们自己更需要的是更强大的大脑，还是替你干活的小弟。

对我而言，我认为最需要的是更强大的大脑。所以，关于ai系列的文章，我选中claude而不是openclaw。

# 什么是claude
Claude 是 Anthropic 公司开发的专有大语言模型系列，Claude 强调少幻觉、更诚实、更安全，特别适合编码、文档分析、金融法律推理和企业级自动化场景

正是这些优点，使得目前绝大部分公司内的工作都可以让Claude代替你。

但是值得注意的是，是claude代替你，而不是openclaw代替你。

打个比方，openclaw是你的私人管家，它可以调用各种应用程序来执行任务，它干的活是你本身会的活

而claude更像是一个顶级大脑，超强的推理和编码，我们只需要提供想法，它能够聪明的自主完成工作。

也就是说，充分的使用claude，是我们工作性质接下来一环我认为必不可少的一个技能。

claude的最佳场景：
1. 软件开发全流程（架构设计、编码、调试、审查）。
2. 企业知识工作（合同分析、金融建模、法律研究、多文档总结）。
3. 自动化工作流（Agent Teams 处理跨工具任务）。
4. 教育、研究与内容创作（准确性要求高）。

大家可以对号入座，哪些场景是能够让claude替代我们工作的。

举个我构想的例子：

一个软件公司，从 测试环境，测试执行，BUG系统，日志分析，调试设备，代码提交，代码审核，问题复盘，问题汇总，代码注释，设计文档，技术方案 都可以让claude完美的接管执行。那么每个公司和部门只需要plugin和skills就可以替代这些工作内容了。

# claude的缺点
Claude的缺点我认为如下
1. 如何更精准的描述你的需求
2. 如何将工作抽象成skill/plugin
3. 如何让claude为你24小时干活

简单来说就是，怎么将Claude用的更好，就是每个人的实际竞争力。

当然，我仅仅针对个人工作观点，个人工作主要涉及操作系统及底层，其他非此行业不做评价。

# 安装
鉴于不是每个人都会linux，虽然我大部分时间都在linux上操作，为了更多的受众，我以windows为例介绍claude的搭建，比较claude搭建非常简单，跟着下面的办法就能够很快的将claude环境搭建成功。

## nvm安装
我们可以使用nvm来一键安装claude，所以先安装nvm，访问github
> https://github.com/coreybutler/nvm-windows/releases


![image.png](/static/img/9aecd6e11d91604bf628264e467ae269.image.webp)

下载后点击安装即可。

安装完成之后可以看到版本生效
```
nvm --version
1.2.2
```
## nodejs安装
管理员打开powershell，如下运行
```
# 安装最新 LTS 版本
nvm install lts

# 使用该版本
nvm use lts
```
安装完成之后，验证是否成功
```
node --version
v12.16.2
npm --version
11.9.0
```
## 安装claude
这里直接npm安装
```
npm install -g @anthropic-ai/claude-code
```

当然也有很多其他办法安装，claude官网说的很详细，可以自行查看
> https://claude.ai/downloads

安装成功后，查看版本
```
claude --version
2.1.78 (Claude Code)
```
## 配置config
我们直接创建.claude目录，如下命令
```
New-Item -Path "$env:USERPROFILE\.claude" -ItemType Directory -Force
```
可以看到创建成功
```


    目录: C:\Users\xxx


Mode                 LastWriteTime         Length Name
----                 -------------         ------ ----
d-----         2026/3/18     23:09                .claude
```
接下来新建文件，如下
```
@"
{
  "env": {
    "ANTHROPIC_AUTH_TOKEN": "YOUR_API_KEY",
    "ANTHROPIC_BASE_URL": "YOUR_BASE_URL",
    "ANTHROPIC_MODEL": "YOUR_MODEL"
  },
  "enabledPlugins": {
    "gopls-lsp@claude-plugins-official": true
  }
}
"@ | Out-File -FilePath "$env:USERPROFILE\.claude\settings.json" -Encoding UTF8
```
此时找到`C:\Users\xxx\.claude`目录，打开settings.json，我们需要填入
* YOUR_API_KEY
* YOUR_BASE_URL
* YOUR_MODEL

填入之后启动claude会提示如下错误
```
 Unable to connect to Anthropic services

 Failed to connect to api.anthropic.com: ERR_BAD_REQUEST

 Please check your internet connection and network settings.

 Note: Claude Code might not be available in your country. Check supported countries at
 https://anthropic.com/supported-countries
```
我们运行如下
```
@"
{
  "hasCompletedOnboarding": true
}
"@ | Out-File -FilePath "$env:USERPROFILE\.claude.json" -Encoding UTF8
```
然后输入claude即可出现如下画面
```
 claude

────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
 Accessing workspace:

 C:\WINDOWS\system32

 Quick safety check: Is this a project you created or one you trust? (Like your own code, a well-known open source
 project, or work from your team). If not, take a moment to review what's in this folder first.

 Claude Code'll be able to read, edit, and execute files here.

 Security guide

 > 1. Yes, I trust this folder
   2. No, exit

 Enter to confirm · Esc to cancel
```
此时正常了如下
```
 claude                                                                                          ╭─── Claude Code v2.1.78 ──────────────────────────────────────────────────────────────────────────────────────────╮
│                                              │ Tips for getting started                                          │
│                 Welcome back!                │ Run /init to create a CLAUDE.md file with instructions for Claude │
│                                              │ ───────────────────────────────────────────────────────────────── │
│                    ▐▛███▜▌                   │ Recent activity                                                   │
│                   ▝▜█████▛▘                  │ No recent activity                                                │
│                     ▘▘ ▝▝                    │                                                                   │
│                                              │                                                                   │
│   qwen-max             · API Usage Billing   │                                                                   │
│             D:\claude                        │                                                                   │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯

  ↑ Opus now defaults to 1M context · 5x more room, same pricing

────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
> Try "edit <filepath> to..."
────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
  ? for shortc… Claude Code has switched from npm to nativeinstall er. Run ` laude install` or see https://docs.anth…
```

# 总结
到这里claude就完全安装成功了。





















AI使用指南(1)-claude介绍

下面继续分析其他的patch
# [PATCH 12/15] sched: Introduce latency-nice as a per-task attribute
这里为 task_struct 提供了 latency_prio 字段，类似于 weight 的 nice value，所以latency_prio越低，则时延要求越高。
```
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -791,6 +791,7 @@ struct task_struct {
 	int				static_prio;
 	int				normal_prio;
 	unsigned int			rt_priority;
+	int				latency_prio;
 
 	struct sched_entity		se;
 	struct sched_rt_entity		rt;

```
所以新增一个 SCHED_FLAG_LATENCY_NICE 代表 用户态可以通过 sched_setattr 来定制化 sched_latency_nice
```
--- a/include/uapi/linux/sched.h
+++ b/include/uapi/linux/sched.h
@@ -132,6 +132,7 @@ struct clone_args {
 #define SCHED_FLAG_KEEP_PARAMS		0x10
 #define SCHED_FLAG_UTIL_CLAMP_MIN	0x20
 #define SCHED_FLAG_UTIL_CLAMP_MAX	0x40
+#define SCHED_FLAG_LATENCY_NICE		0x80
 
 #define SCHED_FLAG_KEEP_ALL	(SCHED_FLAG_KEEP_POLICY | \
 				 SCHED_FLAG_KEEP_PARAMS)
@@ -143,6 +144,7 @@ struct clone_args {
 			 SCHED_FLAG_RECLAIM		| \
 			 SCHED_FLAG_DL_OVERRUN		| \
 			 SCHED_FLAG_KEEP_ALL		| \
-			 SCHED_FLAG_UTIL_CLAMP)
+			 SCHED_FLAG_UTIL_CLAMP		| \
+			 SCHED_FLAG_LATENCY_NICE)
 
 #endif /* _UAPI_LINUX_SCHED_H */

```
 sched_latency_nice的范围是 -20 至 19 
```
 /*
  * Extended scheduling parameters data structure.
@@ -98,6 +99,22 @@ struct sched_param {
  * scheduled on a CPU with no more capacity than the specified value.
  *
  * A task utilization boundary can be reset by setting the attribute to -1.
+ *
+ * Latency Tolerance Attributes
+ * ===========================
+ *
+ * A subset of sched_attr attributes allows to specify the relative latency
+ * requirements of a task with respect to the other tasks running/queued in the
+ * system.
+ *
+ * @ sched_latency_nice	task's latency_nice value
+ *
+ * The latency_nice of a task can have any value in a range of
+ * [MIN_LATENCY_NICE..MAX_LATENCY_NICE].
+ *
+ * A task with latency_nice with the value of LATENCY_NICE_MIN can be
+ * taken for a task requiring a lower latency as opposed to the task with
+ * higher latency_nice.
  */
 struct sched_attr {
 	__u32 size;
@@ -120,6 +137,8 @@ struct sched_attr {
 	__u32 sched_util_min;
 	__u32 sched_util_max;
 
+	/* latency requirement hints */
+	__s32 sched_latency_nice;
 };
 
 #endif /* _UAPI_LINUX_SCHED_TYPES_H */

```
其初始值是 DEFAULT_PRIO
```
--- a/init/init_task.c
+++ b/init/init_task.c
@@ -78,6 +78,7 @@ struct task_struct init_task
 	.prio		= MAX_PRIO - 20,
 	.static_prio	= MAX_PRIO - 20,
 	.normal_prio	= MAX_PRIO - 20,
+	.latency_prio	= DEFAULT_PRIO,
 	.policy		= SCHED_NORMAL,
 	.cpus_ptr	= &init_task.cpus_mask,
 	.user_cpus_ptr	= NULL,
@@ -89,7 +90,7 @@ struct task_struct init_task
 		.fn = do_no_restart_syscall,
 	},

```
fork的时候，prio是 nice 0
```
--- a/kernel/sched/core.c
+++ b/kernel/sched/core.c
@@ -4719,6 +4719,8 @@ int sched_fork(unsigned long clone_flags
 		p->prio = p->normal_prio = p->static_prio;
 		set_load_weight(p, false);
 
+		p->latency_prio = NICE_TO_PRIO(0);
+
 		/*
 		 * We don't need the reset flag anymore after the fork. It has
 		 * fulfilled its duty:

```
__sched_setscheduler 的具体实现
```
+static void __setscheduler_latency(struct task_struct *p,
+				   const struct sched_attr *attr)
+{
+	if (attr->sched_flags & SCHED_FLAG_LATENCY_NICE)
+		p->latency_prio = NICE_TO_PRIO(attr->sched_latency_nice);
+}
+
 /*
  * Check the target process has a UID that matches the current process's:
  */
@@ -7641,6 +7650,13 @@ static int __sched_setscheduler(struct t
 			return retval;
 	}
 
+	if (attr->sched_flags & SCHED_FLAG_LATENCY_NICE) {
+		if (attr->sched_latency_nice > MAX_NICE)
+			return -EINVAL;
+		if (attr->sched_latency_nice < MIN_NICE)
+			return -EINVAL;
+	}
+
 	if (pi)
 		cpuset_read_lock();
 
@@ -7675,6 +7691,9 @@ static int __sched_setscheduler(struct t
 			goto change;
 		if (attr->sched_flags & SCHED_FLAG_UTIL_CLAMP)
 			goto change;
+		if (attr->sched_flags & SCHED_FLAG_LATENCY_NICE &&
+		    attr->sched_latency_nice != PRIO_TO_NICE(p->latency_prio))
+			goto change;
 
 		p->sched_reset_on_fork = reset_on_fork;
 		retval = 0;
@@ -7763,6 +7782,7 @@ static int __sched_setscheduler(struct t
 		__setscheduler_params(p, attr);
 		__setscheduler_prio(p, newprio);
 	}
+	__setscheduler_latency(p, attr);
 	__setscheduler_uclamp(p, attr);

```
# [PATCH 13/15] sched/fair: Implement latency-nice

新增设置 latency_prio 函数
```
--- a/kernel/sched/core.c
+++ b/kernel/sched/core.c
@@ -1305,6 +1305,12 @@ static void set_load_weight(struct task_
 	}
 }
 
+static inline void set_latency_prio(struct task_struct *p, int prio)
+{
+	p->latency_prio = prio;
+	set_latency_fair(&p->se, prio - MAX_RT_PRIO);
+}
+

```
然后使用接口来实现设置latency prio，这样可以获得如下映射
* latency-nice 19: ~204.8ms (尽力而为)
* latency-nice -20: ~0.034ms (极低延迟)

```
 /*
--- a/kernel/sched/fair.c
+++ b/kernel/sched/fair.c
@@ -952,6 +952,21 @@ int sched_update_scaling(void)
 }
 #endif
 
+void set_latency_fair(struct sched_entity *se, int prio)
+{
+	u32 weight = sched_prio_to_weight[prio];
+	u64 base = sysctl_sched_base_slice;
+
+	/*
+	 * For EEVDF the virtual time slope is determined by w_i (iow.
+	 * nice) while the request time r_i is determined by
+	 * latency-nice.
+	 *
+	 * Smaller request gets better latency.
+	 */
+	se->slice = div_u64(base << SCHED_FIXEDPOINT_SHIFT, weight);
+}
+

```
set_latency_fair 在 set_latency_prio 下使用，这里乘以1024，然后除上weight来计算期望的slice

# [PATCH 14/15] sched/fair: Add sched group latency support
这笔patch针对 cgroup 的 task_group 来完善set latency
```
--- a/kernel/sched/sched.h
+++ b/kernel/sched/sched.h
@@ -378,6 +378,8 @@ struct task_group {
 
 	/* A positive value indicates that this is a SCHED_IDLE group. */
 	int			idle;
+	/* latency priority of the group. */
+	int			latency_prio;
 
 #ifdef	CONFIG_SMP
 	/*
@@ -488,6 +490,8 @@ extern int sched_group_set_shares(struct
 
 extern int sched_group_set_idle(struct task_group *tg, long idle);
 
+extern int sched_group_set_latency(struct task_group *tg, int prio);
+

```
```
+static int cpu_latency_nice_write_s64(struct cgroup_subsys_state *css,
+				     struct cftype *cft, s64 nice)
+{
+	int prio;
+
+	if (nice < MIN_NICE || nice > MAX_NICE)
+		return -ERANGE;
+
+	prio = NICE_TO_PRIO(nice);
+
+	return sched_group_set_latency(css_tg(css), prio);
+}
 #endif

```
```
@@ -11408,6 +11432,12 @@ static struct cftype cpu_files[] = {
 		.read_s64 = cpu_idle_read_s64,
 		.write_s64 = cpu_idle_write_s64,
 	},
+	{
+		.name = "latency.nice",
+		.flags = CFTYPE_NOT_ON_ROOT,
+		.read_s64 = cpu_latency_nice_read_s64,
+		.write_s64 = cpu_latency_nice_write_s64,
+	},
 #endif
 #ifdef CONFIG_CFS_BANDWIDTH

```
这样在cgroup v2上的cpu.latency.nice，直接作用到cpu_latency_nice_read_s64和cpu_latency_nice_write_s64上

同样

新增的 sched_group_set_latency 可以对 task_group 更新 latency prio，这里lantency prio 一旦更新，group 下所有 se 的 slice 值也同步更新

# [PATCH 15/15] sched/eevdf: Use sched_attr::sched_runtime to set request/slice
```
--- a/kernel/sched/core.c
+++ b/kernel/sched/core.c
@@ -7494,10 +7494,18 @@ static void __setscheduler_params(struct
 
 	p->policy = policy;
 
-	if (dl_policy(policy))
+	if (dl_policy(policy)) {
 		__setparam_dl(p, attr);
-	else if (fair_policy(policy))
+	} else if (fair_policy(policy)) {
 		p->static_prio = NICE_TO_PRIO(attr->sched_nice);
+		if (attr->sched_runtime) {
+			p->se.slice = clamp_t(u64, attr->sched_runtime,
+					      NSEC_PER_MSEC/10,   /* HZ=1000 * 10 */
+					      NSEC_PER_MSEC*100); /* HZ=100  / 10 */
+		} else {
+			p->se.slice = sysctl_sched_base_slice;
+		}
+	}
 
 	/*
 	 * __sched_setscheduler() ensures attr->sched_priority == 0 when
@@ -7689,7 +7697,9 @@ static int __sched_setscheduler(struct t
 	 * but store a possible modification of reset_on_fork.
 	 */
 	if (unlikely(policy == p->policy)) {
-		if (fair_policy(policy) && attr->sched_nice != task_nice(p))
+		if (fair_policy(policy) &&
+		    (attr->sched_nice != task_nice(p) ||
+		     (attr->sched_runtime && attr->sched_runtime != p->se.slice)))
 			goto change;
 		if (rt_policy(policy) && attr->sched_priority != p->rt_priority)
 			goto change;
@@ -8017,12 +8027,14 @@ static int sched_copy_attr(struct sched_
 
 static void get_params(struct task_struct *p, struct sched_attr *attr)
 {
-	if (task_has_dl_policy(p))
+	if (task_has_dl_policy(p)) {
 		__getparam_dl(p, attr);
-	else if (task_has_rt_policy(p))
+	} else if (task_has_rt_policy(p)) {
 		attr->sched_priority = p->rt_priority;
-	else
+	} else {
 		attr->sched_nice = task_nice(p);
+		attr->sched_runtime = p->se.slice;
+	}
 }
 
 /**

```
鉴于某些应用有精确的延迟要求，这里提供更精确的设置办法

# 总结
EEVDF的patch基本上都分析完成了，关于调度相关的原理的东西基本完结，但是针对调度而言，个人认为还有如下未尽事宜。
1. sched_ext 原理
2. eas 调度
3. PREEMPT_RT 补丁
4. RTLA分析：https://retis.sssup.it/~d.casini/papers/2025/TC2025/Timerlat_TC.pdf
5. Deadline 调度
6. bench工具：Schbench/Hackbench/Cyclictest
7. 维测工具：perfetto

鉴于现在AI特别的火，系统性的学习AI也至关重要，上面未尽事宜等什么时候有空再更新。转战AI。


# 参考
> https://lore.kernel.org/lkml/20230531124604.410388887@infradead.org/
> https://lore.kernel.org/lkml/20230531124604.477939524@infradead.org/
> https://lore.kernel.org/lkml/20230531124604.546980086@infradead.org/
> https://lore.kernel.org/lkml/20230531124604.615053451@infradead.org/












调度(21)-EEVDF补丁解析5

继续分析eevdf的提交patch。

### [PATCH 07/15] sched/smp: Use lag to simplify cross-runqueue placement

首先，不需要再通过min_vruntime来更新vruntime，直接调用之前补丁实现的place_entity

```c
static void
enqueue_entity(struct cfs_rq *cfs_rq, struct sched_entity *se, int flags)
{
-       bool renorm = !(flags & ENQUEUE_WAKEUP) || (flags & ENQUEUE_MIGRATED);
        bool curr = cfs_rq->curr == se;

        /*
         * If we're the current task, we must renormalise before calling
         * update_curr().
         */
-       if (renorm && curr)
-               se->vruntime += cfs_rq->min_vruntime;
+       if (curr)
+               place_entity(cfs_rq, se, 0);
```
dequeue这部分，也是删除了之前cfs的自减min_vruntime，这个之前文章提过。

也因此 enqueue 时 不再只有ENQUEUE_WAKEUP的时候才 place_entity ，所以 dequeue 的时候对应要做 update_entity_lag
```c
@@ -5335,23 +5306,12 @@ dequeue_entity(struct cfs_rq *cfs_rq, st
 
 	clear_buddies(cfs_rq, se);
 
-	if (flags & DEQUEUE_SLEEP)
-		update_entity_lag(cfs_rq, se);
-
+	update_entity_lag(cfs_rq, se);
 	if (se != cfs_rq->curr)
 		__dequeue_entity(cfs_rq, se);
 	se->on_rq = 0;
 	account_entity_dequeue(cfs_rq, se);
 
-	/*
-	 * Normalize after update_curr(); which will also have moved
-	 * min_vruntime if @se is the one holding it back. But before doing
-	 * update_min_vruntime() again, which will discount @se's position and
-	 * can move min_vruntime forward still more.
-	 */
-	if (!(flags & DEQUEUE_SLEEP))
-		se->vruntime -= cfs_rq->min_vruntime;
-
 	/* return excess runtime on last dequeue */
 	return_cfs_rq_runtime(cfs_rq);
 

```
migrate_task_rq_fair 在cfs中的时候，需要重新计算vruntime，这里使用eevdf，删掉

```c
@@ -8102,18 +8062,6 @@ static void migrate_task_rq_fair(struct
 {
 	struct sched_entity *se = &p->se;
 
-	/*
-	 * As blocked tasks retain absolute vruntime the migration needs to
-	 * deal with this by subtracting the old and adding the new
-	 * min_vruntime -- the latter is done by enqueue_entity() when placing
-	 * the task on the new runqueue.
-	 */
-	if (READ_ONCE(p->__state) == TASK_WAKING) {
-		struct cfs_rq *cfs_rq = cfs_rq_of(se);
-
-		se->vruntime -= u64_u32_load(cfs_rq->min_vruntime);
-	}
-
 	if (!task_on_rq_migrating(p)) {
 		remove_entity_load_avg(se);

```

task_fork_fair 也不需要调整vruntime，新版的place_entity 可以直接计算 se 的vruntime，所以删掉

值得注意的是 sysctl_sched_child_runs_first 本身是针对有child 需要先 于 parent 获得cpu的功能，这里eevdf直接删掉
```c
@@ -12492,22 +12440,9 @@ static void task_fork_fair(struct task_s
 
 	cfs_rq = task_cfs_rq(current);
 	curr = cfs_rq->curr;
-	if (curr) {
+	if (curr)
 		update_curr(cfs_rq);
-		se->vruntime = curr->vruntime;
-	}
 	place_entity(cfs_rq, se, 1);
-
-	if (sysctl_sched_child_runs_first && curr && entity_before(curr, se)) {
-		/*
-		 * Upon rescheduling, sched_class::put_prev_task() will place
-		 * 'current' within the tree based on its new key value.
-		 */
-		swap(curr->vruntime, se->vruntime);
-		resched_curr(rq);
-	}
-
-	se->vruntime -= cfs_rq->min_vruntime;
 	rq_unlock(rq, &rf);
 }

```
标准函数vruntime_normalized直接删掉，其本意是判断一个任务是否需要重平衡，这里在 detach_task_cfs_rq 和 detach_task_cfs_rq 一并删掉
```
@@ -12634,16 +12541,6 @@ static void attach_entity_cfs_rq(struct
 static void detach_task_cfs_rq(struct task_struct *p)
 {
 	struct sched_entity *se = &p->se;
-	struct cfs_rq *cfs_rq = cfs_rq_of(se);
-
-	if (!vruntime_normalized(p)) {
-		/*
-		 * Fix up our vruntime so that the current sleep doesn't
-		 * cause 'unlimited' sleep bonus.
-		 */
-		place_entity(cfs_rq, se, 0);
-		se->vruntime -= cfs_rq->min_vruntime;
-	}
 
 	detach_entity_cfs_rq(se);
 }
@@ -12651,12 +12548,8 @@ static void detach_task_cfs_rq(struct ta
 static void attach_task_cfs_rq(struct task_struct *p)
 {
 	struct sched_entity *se = &p->se;
-	struct cfs_rq *cfs_rq = cfs_rq_of(se);
 
 	attach_entity_cfs_rq(se);
-
-	if (!vruntime_normalized(p))
-		se->vruntime += cfs_rq->min_vruntime;
 }
 

```

### [PATCH 08/15] sched: Commit to EEVDF

这里直接删掉原cfs的 sysctl_sched_latency 和 sysctl_sched_wakeup_granularity
```c
-unsigned int sysctl_sched_latency                     = 6000000ULL;
-unsigned int sysctl_sched_wakeup_granularity          = 1000000UL;
+unsigned int sysctl_sched_base_slice                  = 750000ULL;
```

删掉`LAST_BUDDY`、`SKIP_BUDDY`buddy机制
```
--- a/kernel/sched/sched.h
+++ b/kernel/sched/sched.h
@@ -576,8 +576,6 @@ struct cfs_rq {
 	 */
 	struct sched_entity	*curr;
 	struct sched_entity	*next;
-	struct sched_entity	*last;
-	struct sched_entity	*skip;
 
```
在CFS的时候，需要做特殊处理如下
* 当任务yield的时候，标识为 skip buddy，这样可以判断跳过这个任务的选取
* 最后一次唤醒的时候，标识为 last buddy，这样cfs更容易选中这个被唤醒的任务

但是这在eevdf都是不需要的，因为它只需要一个关键 deadline

```
@@ -1098,35 +961,25 @@ static void update_deadline(struct cfs_r
 	if ((s64)(se->vruntime - se->deadline) < 0)
 		return;
 
-	if (sched_feat(EEVDF)) {
-		/*
-		 * For EEVDF the virtual time slope is determined by w_i (iow.
-		 * nice) while the request time r_i is determined by
-		 * sysctl_sched_min_granularity.
-		 */
-		se->slice = sysctl_sched_min_granularity;
-
-		/*
-		 * The task has consumed its request, reschedule.
-		 */
-		if (cfs_rq->nr_running > 1) {
-			resched_curr(rq_of(cfs_rq));
-			clear_buddies(cfs_rq, se);
-		}
-	} else {
-		/*
-		 * When many tasks blow up the sched_period; it is possible
-		 * that sched_slice() reports unusually large results (when
-		 * many tasks are very light for example). Therefore impose a
-		 * maximum.
-		 */
-		se->slice = min_t(u64, sched_slice(cfs_rq, se), sysctl_sched_latency);
-	}
+	/*
+	 * For EEVDF the virtual time slope is determined by w_i (iow.
+	 * nice) while the request time r_i is determined by
+	 * sysctl_sched_min_granularity.
+	 */
+	se->slice = sysctl_sched_min_granularity;
 
 	/*
 	 * EEVDF: vd_i = ve_i + r_i / w_i
 	 */
 	se->deadline = se->vruntime + calc_delta_fair(se->slice, se);
+
+	/*
+	 * The task has consumed its request, reschedule.
+	 */
+	if (cfs_rq->nr_running > 1) {
+		resched_curr(rq_of(cfs_rq));
+		clear_buddies(cfs_rq, se);
+	}
 }

```
根据上面的代码，可以看到，直接给slice为sysctl_sched_min_granularity，把之前一些兼容cfs的东西删掉

```
-/*
- * Preempt the current task with a newly woken task if needed:
- */
-static void
-check_preempt_tick(struct cfs_rq *cfs_rq, struct sched_entity *curr)
-{
-	unsigned long delta_exec;
-	struct sched_entity *se;
-	s64 delta;
-
-	delta_exec = curr->sum_exec_runtime - curr->prev_sum_exec_runtime;
-	if (delta_exec > curr->slice) {
-		resched_curr(rq_of(cfs_rq));
-		/*
-		 * The current task ran long enough, ensure it doesn't get
-		 * re-elected due to buddy favours.
-		 */
-		clear_buddies(cfs_rq, curr);
-		return;
-	}
-
-	/*
-	 * Ensure that a task that missed wakeup preemption by a
-	 * narrow margin doesn't have to wait for a full slice.
-	 * This also mitigates buddy induced latencies under load.
-	 */
-	if (delta_exec < sysctl_sched_min_granularity)
-		return;
-
-	se = __pick_first_entity(cfs_rq);
-	delta = curr->vruntime - se->vruntime;
-
-	if (delta < 0)
-		return;
-
-	if (delta > curr->slice)
-		resched_curr(rq_of(cfs_rq));
-}
-

```
删掉cfs独有的check_preempt_tick

```
 /*
  * Pick the next process, keeping these things in mind, in this order:
  * 1) keep things fair between processes/task groups
@@ -5420,53 +5189,14 @@ wakeup_preempt_entity(struct sched_entit
 static struct sched_entity *
 pick_next_entity(struct cfs_rq *cfs_rq, struct sched_entity *curr)
 {
-	struct sched_entity *left, *se;
-
-	if (sched_feat(EEVDF)) {
-		/*
-		 * Enabling NEXT_BUDDY will affect latency but not fairness.
-		 */
-		if (sched_feat(NEXT_BUDDY) &&
-		    cfs_rq->next && entity_eligible(cfs_rq, cfs_rq->next))
-			return cfs_rq->next;
-
-		return pick_eevdf(cfs_rq);
-	}
-
-	se = left = pick_cfs(cfs_rq, curr);
-
 	/*
-	 * Avoid running the skip buddy, if running something else can
-	 * be done without getting too unfair.
+	 * Enabling NEXT_BUDDY will affect latency but not fairness.
 	 */
-	if (cfs_rq->skip && cfs_rq->skip == se) {
-		struct sched_entity *second;
+	if (sched_feat(NEXT_BUDDY) &&
+	    cfs_rq->next && entity_eligible(cfs_rq, cfs_rq->next))
+		return cfs_rq->next;
 
-		if (se == curr) {
-			second = __pick_first_entity(cfs_rq);
-		} else {
-			second = __pick_next_entity(se);
-			if (!second || (curr && entity_before(curr, second)))
-				second = curr;
-		}
-
-		if (second && wakeup_preempt_entity(second, left) < 1)
-			se = second;
-	}
-
-	if (cfs_rq->next && wakeup_preempt_entity(cfs_rq->next, left) < 1) {
-		/*
-		 * Someone really wants this to run. If it's not unfair, run it.
-		 */
-		se = cfs_rq->next;
-	} else if (cfs_rq->last && wakeup_preempt_entity(cfs_rq->last, left) < 1) {
-		/*
-		 * Prefer last buddy, try to return the CPU to a preempted task.
-		 */
-		se = cfs_rq->last;
-	}
-
-	return se;
+	return pick_eevdf(cfs_rq);
 }

```
pick_next_entity 全面删除cfs的逻辑，只留下eevdf的内容

其他一些删除的东西，这里略过一下。详细可以查看后面的参考链接

### [PATCH 09/15] sched/debug: Rename min_granularity to base_slice

```c
-unsigned int sysctl_sched_min_granularity           = 750000ULL;
+unsigned int sysctl_sched_base_slice           = 750000ULL;
```
重命名，其目的为：
- `min_granularity`暗示了CFS中时间片的最小保证
- `base_slice`明确表示这是EEVDF中任务的基本请求时间

在EEVDF中，slice不再是最小保证，而是计算虚拟deadline的基础参数：
```
se->deadline = se->vruntime + calc_delta_fair(se->slice, se);
```

### [PATCH 10/15] sched/fair: Propagate enqueue flags into place_entity()

新增了 ENQUEUE_INITIAL 的flag
```c
-static void place_entity(struct cfs_rq *cfs_rq, struct sched_entity *se, int initial)
+static void place_entity(struct cfs_rq *cfs_rq, struct sched_entity *se, int flags)
 {
        u64 vslice = calc_delta_fair(se->slice, se);
        u64 vruntime = avg_vruntime(cfs_rq);

        /*
         * on average, halfway through their slice, as such start tasks
         * off with half a slice to ease into the competition.
         */
-       if (sched_feat(PLACE_DEADLINE_INITIAL) && initial)
+       if (sched_feat(PLACE_DEADLINE_INITIAL) && (flags & ENQUEUE_INITIAL))
                vslice /= 2;
```

这个initial和wakeup，migrated平级了。

- `ENQUEUE_INITIAL`标志用于新fork的任务
- `ENQUEUE_WAKEUP`标志用于唤醒的任务
- `ENQUEUE_MIGRATED`标志用于迁移的任务

### [PATCH 11/15] sched/eevdf: Better handle mixed slice length
首先 引入 avg_slice 的概念。基本上和 avg_vruntime 的概念类似，是对时间的平均累加和。
```
--- a/kernel/sched/fair.c
+++ b/kernel/sched/fair.c
@@ -642,6 +642,7 @@ avg_vruntime_add(struct cfs_rq *cfs_rq,
 	s64 key = entity_key(cfs_rq, se);
 
 	cfs_rq->avg_vruntime += key * weight;
+	cfs_rq->avg_slice += se->slice * weight;
 	cfs_rq->avg_load += weight;
 }
 
@@ -652,6 +653,7 @@ avg_vruntime_sub(struct cfs_rq *cfs_rq,
 	s64 key = entity_key(cfs_rq, se);
 
 	cfs_rq->avg_vruntime -= key * weight;
+	cfs_rq->avg_slice -= se->slice * weight;
 	cfs_rq->avg_load -= weight;
 }

```

entity_has_slept 先判断任务是否是sleep到wakeup，且不是迁移任务，如果满足，则将lag补足

```c
static inline bool
entity_has_slept(struct cfs_rq *cfs_rq, struct sched_entity *se, int flags)
{
        u64 now;

        if (!(flags & ENQUEUE_WAKEUP))
                return false;

        if (flags & ENQUEUE_MIGRATED)
                return true;

        now = rq_clock_task(rq_of(cfs_rq));
        return (s64)(se->exec_start - now) >= se->slice;
}
```
添加一个启发式算法PLACE_FUDGE
```c
 static void
 place_entity(struct cfs_rq *cfs_rq, struct sched_entity *se, int flags)
 {
@@ -4930,6 +4947,19 @@ place_entity(struct cfs_rq *cfs_rq, stru
 		lag = se->vlag;
 
 		/*
+		 * For latency sensitive tasks; those that have a shorter than
+		 * average slice and do not fully consume the slice, transition
+		 * to EEVDF placement strategy #2.
+		 */
+		if (sched_feat(PLACE_FUDGE) &&
+		    (cfs_rq->avg_slice > se->slice * cfs_rq->avg_load) &&
+		    entity_has_slept(cfs_rq, se, flags)) {
+			lag += vslice;
+			if (lag > 0)
+				lag = 0;
+		}
+
+		/*
 		 * If we want to place a task and preserve lag, we have to
 		 * consider the effect of the new entity on the weighted
 		 * average and compensate for this, otherwise lag can quickly

```

这个算法的核心思想是：
1. 当任务的slice小于平均slice时，认为它是延迟敏感任务
2. 如果该任务睡眠时间超过其slice，则将其移动到策略#2
3. 策略#2确保任务立即获得执行资格，避免被大slice任务压制

对于延迟敏感任务，我们希望：
$$
lag_i = w_i \times (V - v_i) \leq r_i
$$
其中`r_i`是任务的请求时间（slice）。当任务睡眠时间超过`r_i`时，我们重置其lag，确保它能够及时获得CPU时间。

## 总结

总结一下这些补丁的核心内容。
1. **SMP优化**：使用lag机制替代min_vruntime的计算
2. **策略统一**：移除了CFS的启发式丑代码
3. **命名清晰**：重命名参数
4. **场景感知**：新增enqueue initial flags
5. **混合负载**：为eevdf添加启发式算法优化不同slice长度任务的调度

# 参考
> https://lore.kernel.org/lkml/20230531124604.068911180@infradead.org/
> https://lore.kernel.org/lkml/20230531124604.137187212@infradead.org/
> https://lore.kernel.org/lkml/20230531124604.205287511@infradead.org/
> https://lore.kernel.org/lkml/20230531124604.274010996@infradead.org/
> https://lore.kernel.org/lkml/20230531124604.341527144@infradead.org/

