关于

文章

首页

今天尝试把静态站迁移到Vercel，所有数据线上化，并且支持在线编辑。

**为什么放弃传统的静态站点？**

维护起来太麻烦，手工维护md和图片链接，实在是石器时代干的事情了，现在我想在页面上想到什么写什么，不再想去关心git、CI/CD、流水线部署。希望这次改动后能增加blog的发布频率

**技术栈（乞丐版白嫖各家free plan）**

文章存储：Vercel Neon(for Postgres)

图片存储：Vercel Storage(Blob)

发邮件：Resend

Redis：Vercel Upstash







#

把blog数据迁移到Vercel Storage

强烈推荐[https://github.com/PeonPing/peon-ping](https://github.com/PeonPing/peon-ping)这个插件，支持war3、red alert、dota2等丰富的包，在claude code停顿或完成任务时及时提醒，vibe coding的乐趣又增加了~
![Momonga.jpeg](https://fftogve7akqiyran.public.blob.vercel-storage.com/Momonga.jpeg)

最好用的claude code插件

周末悠闲地vibe装修blog，把kimi都干限流了。

装修完看着舒服多了，可用性也极大地增强了，现在支持以下features：

1. 

1. 在线add/edit blog
2. 登录，支持github/google
3. 评论
4. 后台管理：审核评论、增/删/改 blog





不得不说，在这个vibe coding时代白嫖各家free plan真是爽，这些PaaS基础设施是一年比一年好了，用AI接起来非常方便。
希望装修完后开始高产起来~

1. ![Screenshot 2026-05-10 at 18.12.25.png](https://fftogve7akqiyran.public.blob.vercel-storage.com/Screenshot%202026-05-10%20at%2018.12.25.png)


![Screenshot 2026-05-10 at 18.10.47.png](https://fftogve7akqiyran.public.blob.vercel-storage.com/Screenshot%202026-05-10%20at%2018.10.47.png)

周末装修blog


## 问题

内核是怎么感知cpu和调度cpu的？也就是说，内核怎么分配进程到某个cpu上执行？

# LDE（Limited Direct Execution Protocol）

> LDE——受限直接执行协议
>
> Direct Execution：直接运行用户代码，比如main函数的所有指令，都直接放到CPU上运行

用户程序只能执行 “非特权指令”（如算术运算、普通内存读写、函数调用等）。

当谈到LDE的时候，就是讲用户态、内核态的时候，那么为什么需要LDE？

<img src="/Users/sawyer/Library/Application Support/typora-user-images/Screenshot 2025-11-20 at 01.48.48.png" alt="Screenshot 2025-11-20 at 01.48.48" style="zoom:50%;" />

### 问题1——使用Direct Execution怎么实现权限控制

回答：通过user mode和kernel mode的切换机制。

为了实现操作系统对进程的权限控制。想象一下，一个进程可以随意读写任何的文件、硬件设备，而不受权限控制，那将是很可怕的事情。

实现：操作系统启动时会初始化一个Trap Table，里面记录了「事件」与「内核处理代码地址」的映射。比如：进程需要执行IO时，需要通过Trap事件进入内核态，由内核来完成权限校验，再执行IO操作。有点像AOP，内核可以在执行系统调用前后做任意逻辑，这是内核实现对进程的权限校验的基础。

#### 事件

- **陷阱（Trap）**：进程主动触发（如系统调用，x86 的 `syscall` 指令）；
- **中断（Interrupt）**：外部设备触发（如键盘输入、硬盘 I/O 完成、时钟中断）；
- **异常（Exception）**：进程执行错误（如除零、访问非法内存、执行特权指令）。

#### 用户态 user mode

code that runs in user mode is restricted in what it can do. For example, when running in user mode, a process can’t issue I/O requests; doing so would result in the processor raising an exception; the OS would then likely kill the process.

#### 内核态 kernel mode

In contrast to user mode is kernel mode, which the operating system (or kernel) runs in. In this mode, code that runs can do what it likes, in-cluding privileged operations such as issuing I/O requests and executing

all types of restricted instructions.

### 问题2——怎么实现进程间切换

如果此时一个进程运行在cpu上，那么内核肯定是没在运行的，那么内核怎么去控制进程切换呢？这有点像个哲学问题😄。

回答：通过时钟中断可以内核重新获得cpu执行时间

# RTFM

| man章节号 | 描述（对应文档类型）              | 典型示例                                                     |
| -------------------- | :-------------------------------- | ------------------------------------------------------------ |
| 1 | 用户命令（可执行程序）            | `man 1 ls`（查看 `ls` 命令用法）、`man 1 grep`               |
| 2      | 系统调用（内核提供的服务接口）    | `man 2 open`（查看 `open()` 系统调用的参数 / 返回值）、`man 2 fork` |
| 3      | 库函数（编程语言库，如 C 标准库） | `man 3 printf`（查看 C 语言 `printf()` 函数）、`man 3 strlen` |
| 4      | 特殊文件（设备文件、文件系统）    | `man 4 tty`（查看终端设备文件 `/dev/tty`）、`man 4 ext4`（ext4 文件系统说明） |
| 5      | 配置文件格式（含文件约定）        | `man 5 passwd`（查看 `/etc/passwd` 配置文件的格式）、`man 5 fstab` |
| 6      | 游戏（较少使用）                  | `man 6 fortune`（查看 `fortune` 小游戏命令）                 |
| 7      | 杂项（协议、文件格式、宏等）      | `man 7 utf-8`（查看 UTF-8 编码规范）、`man 7 regex`（正则表达式语法） |
| 8      | 系统管理命令（root 用户常用）     | `man 8 sudo`（查看 `sudo` 管理命令）、`man 8 fdisk`（磁盘分区工具） |
| 9      | 内核相关（内核函数、模块）        | `man 9 printk`（内核打印函数）、`man 9 module_init`（内核模块初始化） |

## C语言库函数

| 函数  | 作用 | 备注 |
| ----- | ---- | ---- |
| fork  |      |      |
| exec  |      |      |
| open  |      |      |
| close |      |      |
| dup   |      |      |
| dup2  |      |      |
| pipe  |      |      |

# 一次cpu上下文切换需要多长时间？

结论：在mac m4上需要1.4微秒左右

```text
Total time: 296200 microseconds
Iterations: 100000
Average context switch cost: 1.4810 microseconds
```

写了一个benchmark来计算。

逻辑：两个进程，绑定在同一个cpu上（sched_setaffinity，仅Linux使用），创建两个pipe，在一个很大的循环下，进程1写pipe1读pipe2，进程2读pipe1写pipe2，通过gettimeofday来计算时间。

```c
#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>
#include <sys/time.h>
#include <sched.h>

#ifdef __APPLE__
#include <mach/mach.h>
#include <mach/thread_policy.h>
#endif

#define ITERATIONS 100000

// Function to bind the current process/thread to a specific CPU core
void bind_to_cpu(int cpu_id) {
#ifdef __linux__
    cpu_set_t mask;
    CPU_ZERO(&mask);
    CPU_SET(cpu_id, &mask);
    if (sched_setaffinity(0, sizeof(mask), &mask) == -1) {
        perror("sched_setaffinity");
        exit(EXIT_FAILURE);
    }
#elif defined(__APPLE__)
    // macOS doesn't have sched_setaffinity, use Mach thread policy
    // This is a "hint" to the scheduler, not a strict guarantee like Linux
    thread_affinity_policy_data_t policy = { cpu_id };
    thread_port_t thread = mach_thread_self();
    kern_return_t ret = thread_policy_set(thread, THREAD_AFFINITY_POLICY,
                                          (thread_policy_t)&policy,
                                          THREAD_AFFINITY_POLICY_COUNT);
    if (ret != KERN_SUCCESS) {
        fprintf(stderr, "Warning: thread_policy_set failed: %d. Continuing without explicit affinity.\n", ret);
        // Do not exit, just continue
    }
#else
    // Fallback for other OSs
    fprintf(stderr, "Warning: CPU pinning not supported on this platform.\n");
#endif
}

int main() {
    int pipe1[2], pipe2[2];
    pid_t pid;
    char buf = 'x';
    struct timeval start, end;

    // Create two pipes
    if (pipe(pipe1) == -1 || pipe(pipe2) == -1) {
        perror("pipe");
        exit(EXIT_FAILURE);
    }

    // Fork the process
    pid = fork();
    if (pid == -1) {
        perror("fork");
        exit(EXIT_FAILURE);
    }

    // Bind both processes to the same CPU (e.g., CPU 0) to avoid cross-CPU migration costs
    // and ensure we are measuring context switch overhead on a single core.
    bind_to_cpu(0);

    if (pid == 0) { // Child process
        // Close unused ends
        close(pipe1[1]); // Child reads from pipe1
        close(pipe2[0]); // Child writes to pipe2

        for (int i = 0; i < ITERATIONS; i++) {
            // Read from pipe1 (blocks until parent writes)
            if (read(pipe1[0], &buf, 1) != 1) {
                perror("child read");
                exit(EXIT_FAILURE);
            }
            // Write to pipe2 (wakes up parent)
            if (write(pipe2[1], &buf, 1) != 1) {
                perror("child write");
                exit(EXIT_FAILURE);
            }
        }

        close(pipe1[0]);
        close(pipe2[1]);
        exit(EXIT_SUCCESS);
    } else { // Parent process
        // Close unused ends
        close(pipe1[0]); // Parent writes to pipe1
        close(pipe2[1]); // Parent reads from pipe2

        gettimeofday(&start, NULL);

        for (int i = 0; i < ITERATIONS; i++) {
            // Write to pipe1 (wakes up child)
            if (write(pipe1[1], &buf, 1) != 1) {
                perror("parent write");
                exit(EXIT_FAILURE);
            }
            // Read from pipe2 (blocks until child writes)
            if (read(pipe2[0], &buf, 1) != 1) {
                perror("parent read");
                exit(EXIT_FAILURE);
            }
        }

        gettimeofday(&end, NULL);

        // Wait for child
        wait(NULL);

        close(pipe1[1]);
        close(pipe2[0]);

        long long start_usec = start.tv_sec * 1000000LL + start.tv_usec;
        long long end_usec = end.tv_sec * 1000000LL + end.tv_usec;
        long long diff_usec = end_usec - start_usec;

        // Each iteration involves 2 context switches:
        // 1. Parent -> Child (when parent waits for read)
        // 2. Child -> Parent (when child waits for read or finishes)
        double context_switch_cost = (double)diff_usec / (ITERATIONS * 2);

        printf("Total time: %lld microseconds\n", diff_usec);
        printf("Iterations: %d\n", ITERATIONS);
        printf("Average context switch cost: %.4f microseconds\n", context_switch_cost);
    }

    return 0;
}

```

# 进程调度算法

关注指标（平均值）：

1. turnaround time 周转时间：任务结束时间 - 任务提交时间
2. response time 响应时间：任务首次运行时间 - 任务提交时间

> scheduling quantum：调度时间片，也称为time slice

| 算法                 | 核心优点（turnaround time /response time）                   | 核心缺点（turnaround time /response time）                   |
| -------------------- | ------------------------------------------------------------ | ------------------------------------------------------------ |
| SJF（非抢占）        | 短进程平均 turnaround time 极优                              | 长进程饥饿（turnaround time 无限延长）；response time 不均（短进程快、长进程慢） |
| STCF（抢占式 SJF）   | 最短作业 / 剩余时间优先，平均 turnaround time 最优           | 长进程饥饿；上下文切换开销增加；短进程 response time 极快，但长进程 response time 极差 |
| RR（时间片轮转）     | response time 公平（所有进程均衡响应）；无饥饿问题           | 平均 turnaround time 较长（受 scheduling quantum 影响）；上下文切换开销高（scheduling quantum 越短越明显） |
| MTFQ（多级反馈队列） | 兼顾短进程（高优先级）和长进程（低优先级）；response time 较均衡；无饥饿（低优先级 scheduling quantum 放大） | 配置复杂（需调优先级数、scheduling quantum 大小）；极端情况下短进程密集时，长进程 turnaround time 偏长 |

## FIFO

FIFO 先来先服务

## Shortest Job First (SJF)

SJF 短作业优先

## Shortest Time-to-Completion First (STCF)

STCF 最短完成时间有限

## Round Robin（RR）

RR 轮训

## Multi-Level Feedback Queue (MLFQ)

MLFQ 多级反馈队列，如今使用最多的进程调度算法。

作用：结合了以上算法的长处，平衡了turnaround time与response time，并且使得整个进程调度更加公平，不会出现饥饿

**规则**

- Rule 1: If Priority(A) Priority(B), A runs (B doesn’t).
- Rule 2: If Priority(A) Priority(B), A & B run in RR.
- Rule 3: When a job enters the system, it is placed at the highest priority (the topmost queue).
- Rule 4: Once a job uses up its time allotment at a given level (re-gardless of how many times it has given up the CPU), its priority is reduced (i.e., it moves down one queue).
- Rule 5: After some time period , move all the jobs in the system
  to the topmost queue.


Notes of OS - Three Easy Pieces

My 2025


最近玩了 Oh My Git 这个游戏，感觉挺有意思的，推荐给大家，顺便记录一下常见的git命令。

```git
切换HEAD到指定commit/branch：git checkout <commitId>/<branch>

把当前branch reset到指定commit：git reset --hard <commitId>

合并分支（无所谓顺序）：git merge <branch>

合并分支（rebase）：git rebase <branch>

切到指定commit并保留current working files：git reset <commitId>
```


Git Commands


row echelon form

martrix determinant












Linear Algebra


Vim 文档中有 Inclusive 和 Exclusive 的表达，但是在用法上难以找到关联两者的一致性。

比如 `f` 和 `F`  在 vim 文档中，前者是 **inclusive** 的，后者是 **exclusive** 的。

```shell
f{char}			To [count]'th occurrence of {char} to the right.  The
			cursor is placed on {char} |inclusive|.
			
F{char}			To the [count]'th occurrence of {char} to the left.
			The cursor is placed on {char} |exclusive|.
```

## Demo

使用 `f` 和 `F` 处理以下文本

```shell
hello world.
```

假设光标在 `^` 位置，按照以上文档的说明

使用 `fw` 时，因为 `f` 是 **inclusive** 的，所以光标会移动到 `w` 

```shell
   hello world.
   ^

✅ hello world.
         ^
```

使用 `Fw` 时，因为 `F` 是 **exclusive** 的，所以光标会移动到 `o` ?

wait, 真的是这样吗？不，答案是会移动到 `w`

这是因为，vim 中的 **exclusive** 和 **inclusive** 是对于 vim motion **最后一个字符**的约束，而对于反向 motion (F) 而言，**最后一个字符**是 `.`

```shell
   hello world.
              ^

❌ hello world.
          ^
           
✅ hello world.
         ^
```

可以用 `dFw` 命令证明这一点。可以看出 `.` 被保留了，因为 `F` 是 **Exclusive** 的

```shell
hello world.
           ^
              
hello .
      ^
```

## Conclusion

在 vim 中 **exclusive** 和 **inclusive** 约束的是 motion 对**最后一个字符的行为**，但需要注意区分 motion 的方向

1. 正向 motion ( f ), **最后一个字符**是 motion 最后一个字符

2. 反向 motion ( F ), **最后一个字符**是 motion 开始第一个字符

Vim 中的 Inclusive & Exclusive


Next.js 的两种预渲染技术：SSG (**Static Site Generation**) 和 SSR (**Server-side Rendering**)。他们的区别在于是何时生成 HTML。

- SSG：在 **build time** 生成 HTML（也可配置为在 **run time** 生成），并且此 HTML 会被每个请求复用，适合 Blog、站点首页和文档等静态页面使用。
- SSR：为每个请求渲染不同 HTML。

BTW，SSG 和 SSR （和客户端渲染）可以在应用中根据需要混合使用，且无论是否使用 SSG or SSR，Next.js 都会默认开启预渲染，服务端首次返回的是正确的 HTML。

## 预渲染 vs. 单页面 SPA

预渲染的好处是服务端首次返回的 HTML 是正确的（**利于 SEO**），这意味着在禁用 JS 的客户端环境下，页面任然可以正常展示，只有交互逻辑无法正常执行。

单页面应用服务端返回的 HTML 是一个空壳，强依赖客户端 JS 代码来渲染页面，禁用 JS 时页面无法正常展示。

## SSR & SSG 预渲染原理

通过 getServerSideProps 或 getStaticProps 在服务端渲染 HTML 页面，所以服务端首次返回的 HTML 是正确的。并且在 HTML 中插入 id 为` __NEXT_DATA__ `  的 `<script>`，客户端 JS 取出  `<script>` 中的 json props 重新渲染页面（Hydration），使交互逻辑可以正常执行。

SSR or SSG 应用代码

```jsx
export default function SSR({ username }) {
  return (
    <>
      <h1> Hello {username} </h1>
    </>
  )
}

// export async function getServerSideProps() {
//   return {
//     props: {
//       username: "Sawyer"
//     },
//   };
// }

export async function getStaticProps() {
  return {
    props: {
      username: "Sawyer"
    }
  }
}
```

Html 返回：

```html
<!DOCTYPE html>
<html lang="en">
    <head>
      ... 省略 head 部分
  	</head>
    <body>
        <div id="__next">
            <h1>
              Hello Sawyer
            </h1>
        </div>
        <script src="/_next/static/chunks/react-refresh.js?ts=1693117005929"></script>
        <script id="__NEXT_DATA__" type="application/json">
            {"props":{"pageProps":{"username":"Sawyer"},"__N_SSP":true},"page":"/ssr","query":{},"buildId":"development","isFallback":false,"gssp":true,"scriptLoader":[]}
        </script>
    </body>
</html>
```

## FAQ

### useEffect 与 预渲染

预渲染期间 React useEffect 不会执行。只有在触发页面渲染 DOM 时，useEffect 才会执行，服务端渲染不会渲染 DOM。

## References

[预渲染服务端 API](https://react.dev/reference/react-dom/server/renderToString)

[pre-rendering](https://nextjs.org/learn/basics/data-fetching/pre-rendering)


Next.js Prerendering


> My introspection to this world.

## 人生的意义

意义是人赋予（Assign）的，所以人生可以有意义，也可以没有意义。

从理性的角度来看，人都是要死的，人对于宇宙来说是无意义的，所以人生是没有意义的，做任何事情都是没有意义的。

从感性的角度来看，人可以为所有事情赋予无穷的含义，所以人生是可以有意义的。

## 他人的看法

> 我活着不是为了满足你的期望，就像你也不是因为我的期望而活着一样

人应该毫不在意他人的看法，包括任何表扬和批评。首先，人的看法是我们不能控制的事物，任何不能控制的事物都是不值得关注的。如果人过分在意他人的看法，因为被表扬而沾沾自喜，而想方设法维持自己的人设，因为被批评而畏手畏脚，那么人无疑是活着别人的眼中，而不是活在自己的世界里。到死的那一天，也许会突然想起：“原来自己表演了一辈子给别人看，没意思”。

所以请去人设化一些，勇敢去做那些自己喜欢做的事。

但是面对表扬和批评，出于对他人的关心，应该假装表现出接受，**这一点很重要**，否则对方可能会认为受到蔑视和侮辱。

## 事物——现在&过去&未来

> 没有意义的事情，是不值得去做的。

事物有三种：

1. 完全能控制的事物（Like present）
2. 能控制一点，但不完全能控制的事物（Like future）
3. 完全不能控制的事物（Like past，cuz the Time Machine haven't been invented yet, lol.）

属于3类型的事物是不值得去做的，所以人应该关注1和2类型的事物。

过去属于3类型的事物，所以过去是不值得用来耿耿于怀的。

Yesterday is history. Tomorrow is a mystery. Today is a gift. That’s why we call it **The Present**.

## 过去 Past & 时光机 Time Machine & 后悔 Regrets

当人总谈起过去，可能是认为现在不够好。

当人谈起时光机的时候，可能他在谈的是后悔。

## 欲望 Desire

人是这样的个体，永远在追求那些任何未得到的东西。然而，追求任何自己未拥有的东西都不会为自己带来安宁。人应该学会想要已经拥有的事物，应该让一件事物发挥其应有的作用。

## 食物

不知道为什么，慢慢对吃的东西不感兴趣了，认为能吃饱、能有足够的营养就满足了。甚至有点想成为素食主义者。

吃美味的食物当然是让人开心的，而我又是属于怎么吃都吃不胖的类型，这就很容易陷入把追求美味的食物的陷阱。因为追求食物和追求金钱一样，也许会带来一时的满足，但不会得到永恒的满足。

## 态度  & 满足 

>  满足感( 其实是多巴胺 )在开始想做事情阶段达到峰值，在达成目标时达到第二个峰值( 比前者低很多 )，在未达成目标时触底。

人控制不了做事情获得的满足感，但是可以控制做事情的态度。

在初中时代，我很喜欢打LOL，每个周末、寒假和暑假，我可以除了吃饭睡觉都一直打LOL。当时我只有一台很烂很破的的笔记本，在它完美工作的情况下（运气好的时候），游戏画面50帧，网络延迟80ms。但我还很庆幸，至少还是可以基本正常进行游戏的。就算这样，我也没同情自己，我能专注享受每一场游戏，拿下了人生的第一个冠军——14岁最强王者。

Fun fact：真正达成目标时，我没有感到非常满足，没有感到非常开心，内心甚至没有太大波澜，这让我有一点失落( I was like, so this is it? nothing more? )。这种失落的感觉让我开始思考，为什么会这样？明明我已经得到了我最想要的东西，为什么会没有那么开心呢？也许这不是我真正想要的？

在看了Atomic Habits后我明白了，"满足感( 其实是多巴胺 )在开始想做事情阶段达到峰值，在达成目标时达到第二个峰值( 比前者低很多 )"。所以这样的体会是正常的，也搞清楚了我得到的东西其实是人格（personality）——自认为打游戏很厉害的人格。

## TODO LIST

引用《黑客与画家》作者的TODO LIST。

1. Don't ignore my dream.
2. Don't work too much.
3. Say what I think.
4. Cultivate friendship.
5. Be happy.

## 错误 Error

犯错不意味着失败，而掩盖错误预示着失败。

## 无知 Ignorance

无知是最适合学习的心态。

希望可以保持无知，Know nothing。

## 职能 Capability

人应该充分发挥人拥有的职能。

从一位明天就要离职但今天还在和我认真地讨论技术和工作问题的朋友体会到了敬业的精神。或者说他在充分发挥人的职能，是一种认真生活的最佳实践。

## 死亡 Death

平静地死去是一种恩赐解脱。

我不害怕死亡，如果我今天会死，那我就今天死去。如果我明天会死，那我就明天死去。我唯一能做的就是好好活着，直到死去。

## 朋友 Friendship

在生命的每个阶段，有一些真心的朋友是值得开心的事。

警惕和持有有毒的价值观的人交朋友，自己的价值观会被这样的人腐蚀，就在不知不觉中。

## 快乐 Joy

进入心流状态的时候最快乐。

## 反思 Introspection

睡觉前的反思：

1. 面对今天事情，我是怎样用我的价值观去应对的
2. 是什么让我睡不着
3. 是什么让我起床

## 悲伤 Grief

悲伤这种情感几乎不能被人的理性控制，所以该悲伤的时候悲伤就好了。

## 灵魂/意志 Soul

人唯一拥有的东西就是自己的灵魂，或者说意志。

## 游戏

进入心流状态最快的方法：打游戏 or Use neovim。

最喜欢的游戏是 DOTA2 ，我认为DOTA2是这个世界上为数不多的较为公平的事物了。

## 融入 Fit in

有时会发现自己无法融入许多环境和圈子，就算在最热闹的场合，也能感受到散发出的隔绝和孤独感，无法逃避。

后来发现其实没什么好融入的，互相觉得对方傻逼才是常态，没必要追求所谓的融入。

我认为融入的定义其实很简单：到任何地方，如果能做到吃得下饭、睡得着觉和起得了床，那么绝对是已经融入成功了。

## 习惯 Habits

Habits cycle  ( from Atomic Habbits ):

1. Cue, a phone buzzes.
2. Crave, want to learn the contents of the message.
3. Response, grab my phone.
4. Reward, satisfied with the craving for reading the message.

Key mindsets to build and preserve a habit:

1. It's about building personalities, neither making perfections nor getting destination.
2. It's about the frequency you repeat the habit. Never miss it twice.

## LOVING

It's better to give than receive.

Love is about giving unconditionally.

## Communication Without Violence

1. State the fact. ( **Caution: distinguish the fact and the opinion** )
2. Express your feeling.
3. Say the requirements.

## Gov

Every nation gets the **gov** it *deserves*. 