The glow of summer has faded, now… and the moonlight jellies carry on toward the great unknown.

The Great Unknown

It has been more than two months since I last wrote a blog post, and three or four months since my last Life Record. Now that it is already the end of July, and I happen to have had a remarkably eventful month, I decided to write it all down.

At the beginning of July, I was “fortunate” enough to be among the first people to finish a pile of CRs. On a whim, I bought a ticket to Chongqing and set out on the first solo trip of my life. To be honest, I was not happy with the trip. Traveling alone only made someone who already tends to wake up at noon even more undisciplined. I really admire badada in this respect. Each day, I had only a few hours in the afternoon to explore. After two years of undergraduate life, my physical condition has deteriorated dramatically. I am more fragile than the chocolate shell of a Chocliz ice cream bar: more than ten minutes in the sun makes me dizzy and nauseous. Chongqing is famously a furnace, so I spent all three days feeling as if I were about to throw up. I also grew up in the waterways of Jiangnan, and every generation of my family is thoroughly from Jiangsu or Zhejiang. I simply cannot handle the numbing spice of Sichuan and Chongqing cuisine. On my first night there, I ordered wontons in chili oil for delivery, and my stomach hurt so badly that I could not sleep. After that I did not dare try any spicy Chongqing food, which of course meant missing quite a few local delicacies. That was a shame. Throughout the trip, I was also harassed by someone who made me physically uncomfortable, and I do not want to say more about that here. In short, the trip was unpleasant and left me rather wary of solo travel. Tomorrow, though, I am heading to Quanzhou and Fuzhou with my bestie.

After returning to Shanghai, I got back to work in the lab. Finals week and all the major course projects had held up my research progress, and I was completely lost in my first meeting back. Thanks to a senior student’s guidance, I quickly found my footing and caught up. I then spent about ten days completing a fairly important component. My senior became busy rushing for the HPCA deadline, however, which left me with another gap of almost ten days. During those ten days, I became obsessed with Stardew Valley. That is also where the title of this post comes from. I had actually played Stardew Valley a long time ago, but it did not appeal to me then, and I quit after a few days. Seeing Yitiaoren so addicted to it made me decide to try again, and just like that, I fell back into it. This time I completely understood what makes the game so wonderful, perhaps because of my state of mind at the moment. Last year I loved playing Honor of Kings, so a laid-back farming game that still required looking up guides on Xiaohongshu did not interest me. But after something very unpleasant happened at the beginning of this year, I never opened Honor of Kings again. Come to think of it, I started playing in third grade, which makes it ten years now. Over those ten years, I have picked it up and put it down many times, each time quitting because of something unpleasant. Stardew Valley, in my view, asks for a whole free evening: you need to clear your mind and immerse yourself completely. With last year’s intense workload, followed by the double assault of coursework and research in the first half of this year, I clearly could not do that. Now I have been lucky enough to find a quiet gap, and my mind is much more at peace. Before summer break, I was constantly anxious. I hoped to push my project forward at full speed over the summer, submit it in September, and use the experience to apply directly for summer research. I soon realized, though, that systems work cannot be completed overnight. My current project has gone through several major refactors and has only now begun to resemble a proper framework. It matters more to make the work solid before submitting it. There is no point rushing summer research applications either. SJTU and Fudan were both added to a blacklist a few days ago, which may mean that getting a J-1 visa will be difficult. If remote work is the only option, the barrier will naturally be somewhat lower. For now, I should focus on the work in front of me. My thoughts about the future have also begun to waver. Recently, HR representatives from several very well-known companies reached out to me, and we had a few conversations. On July 19, I also visited the WAIC exhibition and came away with the strong feeling that if I do not claim a share of this pie soon, there may be none left to claim.

badada and I, two conference freeloaders, sweeping up souvenirs everywhere

Of course, I still have not figured out whether I want to enter industry and make money. I was born into a family that is not particularly short of money, so I do not have much to worry about materially. Yet since childhood, I have had an almost obsessive desire for financial independence. It was also why, when filling out my Gaokao university choices, I decisively gave up PKU’s Yan Garden, which had been my spiritual anchor throughout senior year. As for academia, I am deeply pessimistic about it and have no desire to linger there. The situation changes too quickly; even the direction of the next month is completely unknown. I love encountering new things and am always willing to try them. I love mathematics, especially algebra, which may be the only traditional thing I truly like. I work on systems, but I am completely uninterested in traditional systems and do not want to touch them. I have no regrets at all about choosing computer science as my major. As someone who loves being wherever the action is, how could I not respond enthusiastically to the trend of the era? Looking ahead, WAIC left me very interested in embodied AI and world models. Perhaps I could move into building the relevant infrastructure someday. As for my current multimodal work, I still cannot see what purpose image2 serves beyond pleasing humans. But after reading a blog post, I came to feel that AI4fun is itself a deeply idealistic pursuit. I used to think OpenAI and Gemini should abandon it entirely. In fact, G seems to have already done so. On second thought, though, it has every reason to exist. I seem to have wandered off topic again. The final day of summer in Stardew Valley is the Dance of the Moonlight Jellies. At that moment, I felt as though I had found an anchor for my life right now: I must keep moving toward the great unknown.

It really is beautiful. Sadly, I have no spouse in the game; apparently, if you do, you can watch the jellies dance together with your beloved.

From July 12 to July 24, I attended a computer science summer school jointly organized by SJTU, Tsinghua, and PKU. Being rather physically fragile, I took part in almost none of the off-campus visits and only attended a few classes with mandatory check-ins. The quality of the material varied wildly. Overall, it felt as if SJTU had thrown the courses together merely to tick a box, and I was not very satisfied. During the summer school, however, I met several students from the first-year Yao Class and the second-year information science program. Among them were winners of two NOI gold medals, a provincial Gaokao champion, and people whose spoken English was even better than mine. In my first nineteen years, the chance of encountering people like this was no more than 0.1%. They were all nice and outgoing, and I really enjoyed talking with them. I also look forward to possible academic collaboration in the future.

🥰🥰🥰

This summer, I also completed my first paper submission. After radically reworking my machine learning course project, I tossed the result into the AAAI lottery. My wish is simple: as long as it is not rejected early, that counts as a victory.

And of course, there were the World Cup and F1. Continuing a tradition I started in 2018, I watched the showdown between Spain and Argentina. I have liked Cristiano Ronaldo since 2016. Since practically everyone in my WeChat Moments supports Messi, I hardly even dare admit that, so naturally I was not rooting for Argentina to win. I have also supported Manchester City since 2020. I am very fond of Rodri and De Bruyne, which made Spain versus Belgium painful to watch, and I like Pep Guardiola as well. Unsurprisingly, then, I was supporting Spain. I first noticed Pedri during the 2022 World Cup. Although I am not a Barcelona fan, I really like Pedri himself. A few days ago, during his China tour, I went to Suzhou and saw him in person, which made me incredibly excited. As for F1, the final race before the summer break finally ended the day before yesterday. Lando at last secured his first Grand Prix victory as LN1, and I was delighted. Ferrari’s strategy team, meanwhile, remains as disastrous as ever.

Pedri really is so handsome.

Overall, I have been fairly relaxed this summer. On the one hand, I did reasonably well in my coursework last semester; on the other, I have also made substantial progress in research. I hope I can maintain this state through the rest of the summer and keep moving toward the great unknown.

Finally, when my bestie and I were making travel plans, we were both so lazy that we kept putting everything off and still had no decent itinerary even today. That led me to begin developing Vagebot. Feel free to follow the project. I will finish and open-source it as soon as possible!

夏日的光芒渐渐消失，而月光水母继续向着神秘的未知世界前行……

神秘的未知世界

笔者已经有两个多月没写博客了，更是有三四个月没写 Life Record 了。正好已经到七月底了，笔者碰巧也度过了一个非常精彩的 Jul，遂决定记录一下。

七月刚开始，笔者“有幸”成为了最早完成一堆 cr 的人之一，于是即兴买了一张去重庆的机票，开始了人生中第一次 solo trip。说实话，笔者对这次旅行并不满意。solo trip 让长期中午起床的笔者愈发放纵（这一点真是非常佩服badada），一天只有下午几个小时的行程。而笔者在经过两年本科生活的摧残后身体素质极具下降，比巧乐兹外壳还脆，一旦在太阳下晒超过 10 分钟就会头晕恶心，重庆又是出了名的火炉，笔者这三天一直处在一种想吐的状态。另外，笔者自幼成长在江南水乡，祖祖辈辈清一色的都是江浙一代人，可以说非常原汁原味的江浙人，完全经受不住川渝麻辣的饮食习惯。到重庆的那一晚点了一个 红油抄手 外卖，胃痛的睡不着觉了。笔者便再不敢尝试任何重庆麻辣的食物了，当然也因此错过了不少美味，有些遗憾。旅行过程还持续遭受到令人生理不适的人的骚扰，笔者在此不想多说了。总之，这次旅行并不愉快，笔者也因此对 solo trip 产生了阴影（笔者明天和闺蜜一起去泉州/福州😻）。

回上海后，就开始接着忙实验室的事了。期末周和各种大作业让笔者耽误了一些实验室的进度，回来的第一次 meet 让笔者十分摸不着头脑。感谢学长的指导让我很快找回了状态，也很快跟进了。后面花了 10 天左右完成了一个比较重要的板块，但学长赶 HPCA 去了，于是笔者又有了近 10 天的空窗期。在这 10 天中，笔者迷上了星露谷。这也是这篇博客标题的灵感来源。笔者其实在很久以前就玩过星露谷，但当时对这个游戏实在不是很感冒，玩了几天就弃坑了。但看到 一条人 玩的如此上头，还是决定再试一次，于是就这么再次入坑了。笔者完全 get 到了这款游戏的精彩之处，可能也跟笔者当下的心态有关吧。去年笔者非常喜欢打农，因此对星露谷这种种田休闲还要各种小红书上查攻略的游戏并不感冒。但在今年年初发生的一件很不愉快的事情后，笔者再也没有打开过农。说起来笔者从小学三年级开始农，到如今已有十年了。笔者在这十年中曾多次拾起农又放下农，每次都是因为一些不愉快的事情而放下的😇。星露谷这个游戏，笔者认为是需要一整晚的空余时间，放空心情，完全沉浸在其中的。而显然去年高强度的学习和上半年学业+科研双重攻击下，笔者完全没法做到这一点。但如今笔者非常幸运地有了一段空窗期，心态上比较平和了。在暑假开始前，笔者一直在焦虑，希望暑假能把手上的工作猛猛推进，九月投出去，然后直接用这段经历去套暑研，但很快笔者意识到 sys 的工作并不是一蹴而就的。笔者现在的工作经历了几次比较大的 refactor，才到现在一个初具形态的 framework。把工作做扎实再投更为重要。关于暑研的事，笔者认为急也没用。前几天交复同时被列入黑名单，或许已经意味着 J1 签比较悬了。如果只能做 remote 的话，门槛自然会一定程度上降低一些。还是先忙好手上的活再说吧。而至于未来的出路，也发生了一些动摇。笔者最近收到了几位非常有名的企业的 hr 的联系并聊了一聊，and 笔者在 7.19 参观了 WAIC 的展览，深切地感受到这块蛋糕再不分或许就没的分了。

和 badada 两只会议蝗虫就这样狂嫖纪念品

当然笔者在是否就业赚米这一点上同样没有想清楚。笔者出生在一个不怎么缺钞票的家庭，不存在什么后顾之忧。但笔者自幼就对经济独立有着近乎偏执的态度，这也是笔者在高考填志愿时毅然决然放弃作为高三一整年精神支柱的燕园的原因。至于学界，笔者对此非常悲观，也不愿驻足。局势变化太快，未来一个月的走势都是一种完全的未知状态。笔者非常喜欢接触新鲜事物，而非常愿意积极尝试。笔者很喜欢数学，尤为喜欢代数，这或许是笔者唯一喜欢的传统的东西了。笔者在做 sys，但对传统 sys 可以说是完全不感兴趣也不愿接触。笔者完全不后悔选择 computer science 作为 major，作为一个很爱凑热闹的人，时代的 trend 怎能不积极应对。至于未来，笔者在看过 WAIC 后，对具身和 world model 产生了较大的兴趣，或许未来可以转去做相关的 infra 建设。至于现在的多模态工作，笔者虽然始终没有找到 image2 除了取悦人类之外还有什么任何别的作用，但后来笔者阅读了一篇博客，又觉得 AI4fun 同样是一件非常理想主义的事，笔者本来觉得 openAI 和 gemini 应当完全放弃（事实上 g 好像已经放弃了），但仔细想想完全有存在的理由。好像不知不觉又扯远了。星露谷夏季的最后一天是月光水母节，好像在那一刻，我找到了当下生活的支点，要继续向着神秘的未知世界前进啊！

真的很美啊，可惜我在游戏里没老婆，不然据说能触发和爱人一起看水母起舞🥰🥰

笔者在 7.12 - 7.24 参加了 SJTU-THU-PKU 联合举办的计算机科学暑校活动。笔者由于比较脆皮，几乎没有参与任何外出访学活动，只是听了几节强制签到的课程，讲的内容鱼龙混杂，总体来讲像是泥交为了应付而随意开设的，笔者并不是很满意。但笔者在暑校期间认识了几位来自大一姚班和大二信科的同学，其中不乏两块 noi au 得主、某省高考状元和英语口语比笔者还好的人（笔者在前 19 年遇到这类人的概率不超过 0.1%），他们都很 nice，也很开朗，笔者和他们的交流挺开心的，也期待未来在学术上能有一些合作。

🥰🥰🥰

笔者在这个暑假同样完成了自己的第一次投稿🤣 在爆改了 ML 大作业后，笔者把成果扔给了 AAAI，准备抽奖！许愿只要不被 early rej 就是胜利🤗

哦当然还有世界杯和 F1。笔者延续了从 2018 年开始的习惯，观看了西班牙对战阿根廷的大战。笔者从 2016 年开始喜欢 C罗（出于 puq 清一色梅西球迷，笔者甚至几乎不敢透露这一点），自然不会支持阿根廷夺冠。另外笔者从 20 年开始就一直是曼城的球迷，非常喜欢罗德里和德布劳内（西班牙对比利时真是给我看难受了），也很喜欢瓜帅。故笔者毫不意外地支持西班牙夺冠。笔者在 22 年世界杯的时候认识了佩德里，虽然不是巴萨球迷，但还是很喜欢佩宝个人。于是前几天佩德里中国行笔者前往苏州见到了他本人，另笔者非常兴奋。至于 F1，前天终于结束了夏休前的最后一场比赛。Lando 终于拿下了属于 LN1 的首个分站冠军，笔者非常开心。但窝法依旧雷霆策略组。

佩宝真的好帅吧🥰

总的来讲，笔者这个暑假心态上还是比较放松的，一方面笔者上学期的学业完成的还算不错，另一方面笔者在科研上也有了比较大的进展。笔者希望在接下来的暑假中能继续保持这种状态，向着神秘的未知世界前行啊！

最后，笔者在和好闺蜜制定旅行计划时，由于都比较懒，故一拖再拖，到今天也没有一个比较好的计划。于是笔者开始了 Vagebot 的开发，欢迎各位的关注，笔者会尽快完成并开源！

In recent years, a hot direction in systems research has been Systems for AI: how to make large-model training and inference faster, more memory-efficient, and easier to deploy. ArchLite focuses on the opposite question: Can AI help systems themselves make decisions? Around April this year, I read the ASPLOS 2026 best paper PF-LLM: Large Language Model Hinted Hardware Prefetching, and a question came up: why PF-LLM, but not PF-DNN? PF-LLM indeed achieved good results on prefetching decisions, but its model size and training cost are also nontrivial. This led to the machine-learning course project ArchLite, a comparative study of model scale for static load-level prefetching.

More specifically, ArchLite tries to answer one question:

For static, local, structured microarchitecture decisions, do we really need large language models?

This question was inspired by PF-LLM. PF-LLM models hardware prefetching decisions as prediction tasks over code context. ArchLite does not try to strictly reproduce PF-LLM. Instead, it uses PF-LLM as a case study and investigates model scale itself: on the same locally generated data and labels, it compares rule-based or linear models, compact DNNs, and Qwen2.5 LoRA.

Task: Predicting Prefetch Hints from Assembly Context

The concrete task chosen by ArchLite is static load-level prefetching. Each sample corresponds to a static load PC. The input is the assembly context around that load instruction, and the output is a structured label with three fields:

{
  "PF Sel": "...",
  "PF Degree": "...",
  "Filter": "..."
}

Where:

• PF Sel: which type of prefetcher to choose, such as stream, sms, ip_stride, or sandbox;
• PF Degree: the prefetch degree;
• Filter: whether to use a filtering strategy.

This task is different from general code understanding. It does not require code generation or cross-file reasoning. It is a local supervised-learning problem with a limited output space. Therefore it is well suited for testing whether the scale advantage of large models is truly necessary.

How the Data Is Generated

ArchLite’s labels are not manually annotated. They are generated through system simulation.

The overall process is:

GAPBS graph workload
        ↓
Execution trace
        ↓
Extract static load instructions and assembly context
        ↓
ChampSim grid search over prefetch configurations
        ↓
Use the configuration with the lowest AMAT for each load PC as the label
        ↓
Train and compare LR, DNN, and Qwen2.5 LoRA

GAPBS is used because graph workloads often have irregular memory access patterns, making prefetching decisions nontrivial. ChampSim provides a controllable microarchitecture simulation environment. For each static load PC, ArchLite compares AMAT under different prefetcher configurations and selects the configuration with the lowest AMAT as the supervised label.

The project constructs three datasets, differing in sample-filtering rules:

The balanced test split avoids majority-class dominance hiding model weaknesses, while the original test split preserves the natural distribution.

Model Comparison

ArchLite compares four types of models:

1. Majority baseline: always predicts the most common label in the training set;
2. Logistic Regression: hashed TF-IDF features over assembly tokens;
3. Compact DNN: a small three-head MLP predicting the three fields;
4. Qwen2.5 LoRA: LoRA fine-tuning of Qwen2.5-Coder-0.5B-Instruct.

The most important results come from the largest dataset, mincount1_nomargin:

Qwen2.5 is clearly stronger than Logistic Regression, but it does not significantly dominate the compact DNN. On the balanced split, Qwen’s joint accuracy is only 0.0085 higher than DNN. On the original split, the two are nearly tied.

This is ArchLite’s core observation: for such local, structured system tasks with clear supervised signals, large models are not necessarily the most cost-effective choice.

A More Interesting Finding: Local Context Is Better

ArchLite also performs a context-window ablation. By default, the model can see the full assembly context. But if we keep only the local window around the target load, the result actually improves.

On the largest balanced test split:

In other words, by looking only at eight assembly lines before and after the target load, the compact DNN reaches 0.4764 joint accuracy, exceeding full-context DNN and also exceeding the current Qwen2.5 LoRA result of 0.4291.

This suggests that effective signals for this task may be concentrated near the target instruction. For microarchitecture decisions, more context is not always better. A suitable local representation may match the problem structure more closely.

AMAT Proxy: Not Just Classification Accuracy

Classification accuracy only tells us whether the model predicts the same label. But system tasks ultimately care about performance. Therefore ArchLite also computes an AMAT-level proxy: mapping the predicted prefetch configuration back to ChampSim results and estimating how much oracle prefetching benefit it recovers.

Results:

DNN and Qwen2.5 have almost identical AMAT recovery. This further shows that the compact DNN is not merely close in classification metrics; it also achieves similar downstream performance proxy metrics.

ArchLite’s Conclusion

ArchLite is not saying that LLMs have no value for architecture tasks. Large models may be more suitable for cross-function reasoning, source-code semantic understanding, low-sample transfer, explanation generation, and similar tasks.

It emphasizes a finer judgment:

When the task is local, the output space is limited, and labels can be obtained through simulation or measurement, model scale should be treated as a system design parameter, not as something that is bigger by default.

For tasks like static load-level prefetching, compact DNNs can already capture many learnable signals while being cheaper to train, infer, and deploy.

Limitations and Future Work

Current ArchLite is still a local-data study rather than a complete industrial system. Its main limitations include:

• workloads mainly come from GAPBS and do not yet cover SPEC, server workloads, or broader programs;
• labels come from ChampSim simulation and may differ from real hardware behavior;
• the current split is closer to held-out input generalization than strict cross-program generalization;
• Qwen, DNN, and LR have different hyperparameter search spaces, so the results should be interpreted as a controlled practical comparison rather than an exhaustive search.

Future work can expand to more workloads, stricter cross-program tests, more realistic hardware validation, and more microarchitecture decisions, such as cache bypass, branch behavior, memory dependence, and load/store scheduling.

Summary

ArchLite’s core value is not proposing a new prefetcher. It raises a system design question: does AI for Systems always need large models?

At least on this static prefetching decision task, the answer is not absolute. Qwen2.5 LoRA is effective, but a compact DNN is already very close and even stronger under a local-context setting.

This gives AI for Systems a practical lesson: before introducing LLMs into system optimization, we should carefully examine task granularity, label source, output space, and deployment cost. Many times, the truly suitable model is not the largest one, but the one that best matches the structure of the problem.

过去几年，系统研究里一个很热的方向是 System for AI：怎样让大模型训练和推理更快、更省显存、更容易部署。ArchLite 关注的是反方向的问题：AI 能不能帮助系统本身做决策？ 在今年四月份左右，笔者读了ASPLOS26 best paper PF-LLM: Large Language Model Hinted Hardware Prefetching，产生了一个疑惑，why PF-LLM，but not PF-DNN？PF-LLM 的确在预取决策上取得了不错的效果，但它的模型规模和训练成本也不小。于是便有了这份机器学习大作业———— ArchLite，一个针对静态 load-level prefetching 任务的模型规模对比研究。

更具体一点，ArchLite 想回答一个问题：

对于静态、局部、结构化的微体系结构决策，我们真的需要大语言模型吗？

这个问题来自 PF-LLM 的启发。PF-LLM 将硬件预取相关决策建模成代码上下文上的预测任务。ArchLite 没有尝试严格复现 PF-LLM，而是把它作为一个案例，研究模型规模本身：在同一批本地生成的数据和标签上，比较规则/线性模型、小型 DNN 和 Qwen2.5 LoRA 的表现。

任务：从汇编上下文预测预取 hint

ArchLite 选择的具体任务是静态 load-level prefetching。每个样本对应一个静态 load PC，输入是该 load 指令附近的汇编上下文，输出是一个三字段结构化标签：

{
  "PF Sel": "...",
  "PF Degree": "...",
  "Filter": "..."
}

其中：

• PF Sel：选择哪类预取器，例如 stream、sms、ip_stride、sandbox 等；
• PF Degree：预取程度；
• Filter：是否采用过滤策略。

这个任务和通用代码理解不一样。它不要求生成代码，也不需要跨文件推理，而是一个局部的、有限输出空间的监督学习问题。因此它很适合用来检验：大模型的规模优势是否真的必要。

数据如何生成

ArchLite 的标签不是人工标注的，而是通过系统模拟生成的。

整体流程可以概括为：

GAPBS 图算法 workload
        ↓
执行 trace
        ↓
提取静态 load 指令及其汇编上下文
        ↓
ChampSim 网格搜索不同预取配置
        ↓
用每个 load PC 上 AMAT 最低的配置作为标签
        ↓
训练并比较 LR、DNN、Qwen2.5 LoRA

这里使用 GAPBS 是因为图计算 workload 往往有不规则访存模式，预取决策并不容易。ChampSim 则提供可控的微体系结构模拟环境。对每个静态 load PC，ArchLite 会比较不同预取器配置下的 AMAT，然后选择 AMAT 最低的配置作为监督标签。

项目中构造了三组数据集，区别在于样本过滤规则不同：

其中，balanced test 用于避免多数类掩盖模型缺陷，original test 则保留自然分布。

模型比较

ArchLite 比较了四类模型：

1. Majority baseline：总是预测训练集中最常见的标签；
2. Logistic Regression：基于汇编 token 的 hashed TF-IDF 特征；
3. Compact DNN：小型三头 MLP，预测三个字段；
4. Qwen2.5 LoRA：对 Qwen2.5-Coder-0.5B-Instruct 做 LoRA 微调。

最关键的结果来自最大数据集 mincount1_nomargin：

Qwen2.5 明显强于 Logistic Regression，但它并没有显著压倒小型 DNN。在 balanced split 上，Qwen 的 joint accuracy 只比 DNN 高 0.0085；在 original split 上，两者几乎持平。

这正是 ArchLite 的核心观察：对于这种局部、结构化、监督信号明确的系统任务，大模型并不一定是最划算的选择。

更有意思的发现：局部上下文反而更好

ArchLite 还做了 context-window ablation。默认情况下，模型可以看到完整汇编上下文；但如果只保留目标 load 周围的局部窗口，结果反而更好。

在最大 balanced test 上：

也就是说，只看目标 load 前后各 8 行汇编，小型 DNN 的 joint accuracy 达到 0.4764，超过了 full-context DNN，也超过了当前 Qwen2.5 LoRA 的 0.4291。

这说明这个任务的有效信号可能主要集中在目标指令附近。对微体系结构决策来说，更多上下文不一定更好；合适的局部表示反而更匹配问题本身。

AMAT proxy：不仅是分类准确率

分类准确率只能说明模型是否预测到同一个标签，但系统任务最终关心的是性能。因此 ArchLite 还计算了 AMAT-level proxy：把模型预测的预取配置映射回 ChampSim 结果，估计它能恢复多少 oracle prefetching benefit。

结果如下：

DNN 和 Qwen2.5 的 AMAT recovery 几乎一样。这进一步说明，小型 DNN 不只是分类指标接近，在下游性能代理指标上也能达到相近效果。

ArchLite 的结论

ArchLite 并不是说 LLM 对体系结构任务没有价值。大模型可能更适合跨函数推理、源代码语义理解、低样本迁移、解释生成等任务。

它想强调的是一个更细的判断：

当任务是局部的、输出空间有限的、标签可以通过模拟或测量获得时，模型规模应该是一个系统设计参数，而不是默认越大越好。

对于静态 load-level prefetching 这样的任务，小型 DNN 已经能捕捉大量可学习信号，并且训练、推理和部署成本都更低。

局限与未来方向

当前 ArchLite 仍然是一个本地数据研究，而不是完整工业级系统。它的主要局限包括：

• workload 主要来自 GAPBS，尚未覆盖 SPEC、server workload 等更广泛程序；
• 标签来自 ChampSim 模拟，和真实硬件行为可能存在差异；
• 当前 split 更接近 held-out input generalization，而不是严格的 cross-program generalization；
• Qwen、DNN 和 LR 的调参空间不同，因此结果应理解为受控实践比较，而不是穷尽搜索。

未来可以继续扩展到更多 workload、更严格的跨程序测试、更真实的硬件验证，以及更多微体系结构决策，例如 cache bypass、branch behavior、memory dependence、load/store scheduling 等。

总结

ArchLite 的核心价值不在于提出一个新的预取器，而在于提出了一个系统设计问题：AI for Systems 是否总是需要大模型？

至少在这个静态预取决策任务上，答案并不绝对。Qwen2.5 LoRA 有效，但小型 DNN 已经非常接近，甚至在局部上下文设置下更强。

这给 AI for Systems 一个很实际的启发：在把 LLM 引入系统优化之前，应该先认真判断任务粒度、标签来源、输出空间和部署成本。很多时候，真正合适的模型不是最大的，而是最匹配问题结构的。

Background

The story began when I attended the ACM Honors Class midterm meeting at the end of April. At the meeting, senior wankupi said that no one in our class had volunteered to build an LLM API relay, so the sophomores collectively received yyu’s education once again. At that time, after being badly hit by Copilot Pro and Apple server bugs that prevented region changes, I was furious and started evaluating LLM relay services that could use the Opus series. I also became interested in building such a relay myself. Meanwhile, Parsifal told me that he wanted to earn money by building a relay. I was very tempted, because recently I had spent a large amount of money on tokens, servers, domains, IPs, and birthday gifts for many people. Even a young lady could not hold on forever, so I decided to earn some financial support myself. All these reasons led me to find senior kupi and take on the relay-building task. After nearly a full day of exploration on April 30, with P’s help, I had a fairly clear design and successfully ran it locally. So I decided to write a blog post recording the whole process of building an API relay from scratch.

Initial

At first, the idea was to deploy the relay on an overseas server and let that server forward requests to an overseas static residential IP, in order to avoid Anthropic’s almost terrifying risk controls. Later, after learning that we could obtain access to an ACM class server, we decided to deploy the relay on that server first, then forward subsequent requests to an overseas static residential IP.

A Small Episode

During the May Day holiday, I tried to work from home, but repeatedly failed to connect to the server. Later I learned that the IP under WSL was still my home IP, not the SJTU IP after connecting to the VPN, while the Windows IP was the SJTU IP. So I connected from Windows. Even after enabling Windows network mirroring for WSL, it still could not connect. This left another unresolved pitfall.

Relay Framework

Mainstream relay frameworks include oneAPI, newAPI, sub2API, and others. newAPI is the earliest and relatively most complete, but I had previously used an almost terrible site based on newAPI, so I did not have a good impression of it. In the end I chose sub2API, mainly because its code is relatively clean and its features are complete enough for our needs.

Frontend Polishing

I made some frontend beautification changes, turning sub2API into ACMAPI.

Domain and Intranet Tunneling

To let external users access the relay deployed on the server, we needed a domain and an intranet tunneling tool. We chose Cloudflare for tunneling because it is simple and provides free service. We registered a domain. A .top domain costs only 14 RMB, which made me wonder what my recently renewed 125 RMB .site domain even means. We pointed it to the address provided by Cloudflare, so external users could access our relay through the domain. It successfully ran locally.

At that moment, I did not know that the real challenges were still ahead.

Server Deployment

First, sub2API has a somewhat strange frontend/backend structure. The frontend is written in TypeScript and uses pnpm, while the backend is written in Go.

cd frontend
pnpm install
pnpm run build

cd ../backend
go build -tags embed -o sub2api ./cmd/server

pnpm and go build were almost destructive for our ACM class server. The machine has very little memory and sits behind the SJTU firewall. pnpm build takes a lot of space, and the frontend exploded before compilation finished. The backend compilation was even worse. Go depends on many GitHub-hosted packages, and SJTU’s network environment is extremely unfriendly, causing dependency downloads to fail repeatedly and eventually breaking the build. After being stuck for a whole night, we changed strategy: compile everything locally and throw the results onto the server. Here we recommend rsync for data transfer. It is much, much more efficient than scp.

Next we installed the database and related services on the server, then did another round of tunneling. At that point, the relay deployed on the ACM class server could already be accessed normally.

Then we started considering IP proxy configuration. This was the biggest difficulty.

We found that a server deployed behind the SJTU firewall simply could not connect normally to a static residential IP. Overseas static residential IPs usually require an extra overseas datacenter IP proxy before sending requests. Naturally, the idea became: add a proxy layer on the ACM class server. But if the server could not even access GitHub, how could we install Clash? This became a dead loop. After another night of exploration, we finally installed Clash through a temporary proxy. Because of SJTU DNS restrictions, not every subscription worked with Clash. For this, I was forced to obtain several more proxies. Eventually I found a few that could subscribe successfully. Then, as expected, something unexpected happened. After two proxy layers, we could successfully connect to the overseas residential IP, but the double proxy caused a strange issue: we could not access Anthropic or OpenAI at all. It seemed like they detected the SJTU IP or datacenter IP somewhere in the path and blocked it directly.

So we concluded: it is not feasible to access Anthropic and OpenAI through a relay deployed on an on-campus server. Later, we tried the same setup on a Hong Kong server and succeeded. That became our current commercial relay, joypiggy. If you are interested, feel free to message me privately.

Just when I had run out of options, Boss Zheng told me that we only needed to connect to an upstream relay. Bruh. If it was that simple, I had already done it long ago. What even was that.

jAccount Authentication

This is the part I am proud of: from idea design to implementation and successful running, I completed it independently without outside intervention. jAccount authentication is an important feature of our relay. It ensures that only SJTU students can use it. The key is integrating with SJTU’s authentication system and verifying user identity information.

If you are interested, you can read this article. The final implementation added a jAccount login button on the frontend login page. After clicking it, users are redirected to SJTU’s authentication page, enter their jAccount username and password, and after successful authentication receive a token containing user information. Our relay verifies whether the token is valid, and if it is, allows the user to continue using the relay.

Regrets, or Maybe Future Work

Our original plan was to access it through acm.sjtu.edu.cn/llmapi, using an nginx reverse proxy configuration. Unfortunately, the backend base URL modification logic was too complex, and it seemed related to the jAccount authentication redirect URL. In the end, we could only use the domain I bought. Although that domain is cheap, I still want to solve this issue if there is a chance later.

Website Operations

Before this, I had no website operations experience at all. During the process, I encountered many problems: server environment configuration, database installation and configuration, domain DNS, intranet tunneling, and so on. Every problem gave me headaches. But through constant learning and trial, I eventually built the relay successfully. This is also the part that gave me the strongest sense of achievement.

Senior wankupi gave me many suggestions on website operations, including systemd service configuration and postgres database usage. Many thanks.

Conclusion

The reason we spent so much effort building this relay is, frankly, Anthropic and OpenAI’s various restrictions. It is quite emotional. Has study and research really become a war over tokens? I do not understand.

On April 30, 2026, I posted a topic on Shuiyuan: I want to know what fellow SJTU students think about API relays. https://shuiyuan.sjtu.edu.cn/t/topic/470419 SJTU students are welcome to vote.

And, to repeat once more, if anyone is interested in a cheap, full-power Codex relay without watered-down models, please contact me. Our current commercial relay joypiggy is already online. Welcome to use it.

Finally, thank you to all the seniors, classmates, and Shuiyuan friends who helped me. I am lucky to have you.

bg

事情的起因是这样的，笔者在四月末的某一天参加了 ACM班中期座谈会，会上 wankupi 学长说我们班没有人volunterr去搭建一个大模型的API 中转站，于是大二集体又又又接受了yyu的教育😆 彼时笔者在被 copilot pro和Apple 服务器出bug无法修改地区 狠狠阴了一把后，气急败坏，转头开始测评起了能用 opus系列的大模型中转站，当然也对搭建中转站本身产生了一些兴趣。同时Parsifal跟我说他想通过搭建中转站赚米，笔者听了十分心动，因为笔者近期在token、服务器、域名、ip、以及给一堆人买生日礼物身上花掉了大笔大笔的钱，即便是大小姐也撑不住了，决定要靠自己获得一些经济支持。种种原因就促成了笔者去找了 kupi学长，揽下了搭中转站的活。经过4月30号近一天的摸索，笔者在P老师的帮助下有了一个较为清晰的设计，在本机上也跑成功了，遂决定写一篇博客，记录一下 从 0 开始搭建API中转站 的全过程。

Initial

最开始，想法是把中转站部署在一台海外服务器上，由海外服务器统一转发到一个海外静态住宅ip，以此来规避Anthropic 近乎恐怖的封控力度。但后来得知可以获得ACM班服务器的使用权限，我们最终选择了把中转站部署到这台服务器上，再后续将请求转发到海外静态住宅ip。

小插曲

笔者五一回家期间试图在家干活，连服务器的时候却屡屡碰壁，后来才得知wsl下的ip一直是家里的ip而非连接交大VPN后的交大ip，但windows下的ip是交大ip，遂走了windows连。后来给wsl做了windows网络镜像后依然没法连上，也是留下了一个坑点了。

中转站框架

主流的中转站框架有 oneAPI、newAPI、sub2API等，newAPI是最早的也是相对功能最完善的，但笔者先前用过一个基于newAPI的近乎糟糕的站，所以对 newAPI的印象不太好，最终选择了sub2API，主要是因为它的代码相对简洁，且功能也比较完善，能够满足我们的需求。

前端修缮

作了一些前端的美化工作，turn sub2API to ACMAPI。

域名和内网穿透

为了让外网能够访问到部署在服务器上的中转站，我们需要一个域名和内网穿透工具。我们选择了 cloudflare 作为内网穿透工具，因为它简单易用，且提供了免费的服务。我们注册了一个域名（.top居然只要14，我刚续费125的.site算什么），并将其解析到 cloudflare 提供的地址上，这样外网用户就可以通过这个域名访问我们的中转站了。成功在本机上跑通了。

此时，还不知道，前方的挑战才刚刚开始。

服务器部署

首先，sub2api的前后端较为奇怪，前端采用 typescript 编写，用pnpm进行包管理，而后端则是 go 编写。

cd frontend
pnpm install
pnpm run build

cd ../backend
go build -tags embed -o sub2api ./cmd/server

pnpm 和 go build 对我们的ACM班服务器来说简直是毁灭性的。这是一台内存极小并且在交大防火墙内的服务器，pnpm build需要占用很大的空间，前端还没编译完就炸了。更糟糕的是后端的编译。go语言基于github的依赖包太多，而交大的网络环境又极其不友好，导致编译过程中经常出现下载依赖包失败的情况，最终导致编译失败。被硬控了一个晚上后，我们转变思路，直接在本地编译好一切，统一扔到服务器上。这里我们推荐采用rsync的数据传输方式，效率比scp高很多很多。

接下来就是在服务器上装数据库这些，并且又进行了一次内网穿透，至此其实部署在ACM班服务器上的中转站已经可以正常访问了。

接着开始考虑ip代理配置。这也是遇到的最大的困难。

我们发现，部署在交大防火墙内的服务器根本无法正常连接到静态住宅ip。海外静态住宅ip其实都需要加一层海外机房ip的代理后再发去请求。所以想法自然就来到了，在acm班服务器上加一层代理。然而连github都访问不了，又该如何装 clash 呢？就这样陷入了一个死循环。当然又经过了一个晚上的摸索，通过了临时代理的方式，成功装好了clash。同样受限于交大dns，并非所有的订阅都能用在clash上。为此笔者被迫又获得了好几个梯子（此处应有tieba_hehe），终于找到了几个能成功订阅的。不出意外又要出意外了，经过两次代理后，虽然能够实现成功连通到海外住宅ip上了，但两次代理又带来了很奇怪的问题，完全无法访问Anthropic和OpenAI，疑似是这两家检测出了轨迹上的交大ip或是机房ip，直接封了。

所以我们得出结论：想通过部署在校内服务器上的中转站访问Anthropic和OpenAI是行不通的。后续，我们尝试在一台港区服务器上进行了同样的操作，大获成功，这也成了我们目前的商用中转站joypiggy（快乐小猪🐖），有兴趣的uu们私聊！

就在我实在没招了的时候，郑老板告知其实只需要实现连到上游中转站就行了，bur，这么简单，那我不早就搞定了吗？？？何意味。。。

jAccount 认证

值得骄傲啊，这是笔者从idea设计到实施跑通全部独立完成没有外人干预的一部分。jAccount认证是我们中转站的一个重要功能，它能够确保只有交大学生才能使用我们的中转站。实现这个功能的关键是要与交大的认证系统进行对接，验证用户的身份信息。

感兴趣的可以阅读这篇文章。最后的实现是在前端登录界面添加了一个jAccount登录按钮，用户点击后会跳转到交大的认证页面，用户输入自己的jAccount账号和密码进行认证，认证成功后会返回一个包含用户信息的token，我们的中转站会验证这个token的有效性，如果有效就允许用户继续使用中转站的功能。

遗憾（也或许是future work）

我们本来预期的想法是通过acm.sjtu.edu.cn/llmapi 来进行访问，基于nginx的反向代理配置，但很不幸后端base url 修改逻辑过于复杂，感觉跟jAccount认证的url 跳转有一定关系，导致我们最后还是只能通过我买的域名来访问了，虽然这个域名也很便宜，后续如果有机会的话还是想把这个问题解决掉的。

网站运维

笔者在此之前完全没有过网站运维的经验。整个过程中遇到了很多问题，比如服务器的环境配置、数据库的安装和配置、域名解析、内网穿透等等，每一个问题都让我头疼不已。但是通过不断地学习和尝试，最终还是成功地搭建了这个中转站，这也是我觉得最有成就感的一部分。

wankupi学长给我的网站运维提出了不少意见，包括systemd service的配置、postgres数据库的使用等，非常感谢！！！

结语

我们这样费劲心思搭建的中转站，说白了还是因为 Anthropic 和 OpenAI 的种种限制，令人感慨，现在的学习科研难道真的成了 token 之争吗？我不明白。

2026年4月30号我在水源上发了一个话题，想知道源友对API中转站的看法，https://shuiyuan.sjtu.edu.cn/t/topic/470419，也欢迎交大的同学前去投票。

以及（再重复一遍），如果有同学对便宜且满血不掺水codex中转站感兴趣，欢迎联系我！我们目前的商用中转站joypiggy（快乐小猪🐖）已经上线了，欢迎大家使用！

最后，感谢帮助过我的学长、同学和源友！有你们是我的幸运！

1. Core Concepts and Dispatch Mechanism

CPU-I/O Burst Cycle

A process does not occupy the CPU continuously. Instead, its execution consists of alternating CPU bursts and I/O bursts.

Statistics over a large number of processes show that systems contain many short CPU-burst processes and only a small number of long CPU-burst processes. This distribution is an important basis for designing scheduling algorithms.

Dispatcher & Dispatch Latency

The dispatcher is the module that actually performs the “switch” action. Dispatch latency is the time required to stop one process and start another.

In systems with strict requirements, the conflict phase of dispatch latency is the main bottleneck. It includes two steps:

1. Preempt any process running in kernel mode.
2. Let low-priority processes release the system resources needed by high-priority processes.

2. Core Scheduling Algorithms

FCFS (First-Come, First-Served)

• Pain point: the convoy effect. If a long CPU-bound process is at the front of the queue, a group of short I/O-bound processes behind it are forced to wait for a long time, reducing both CPU and I/O-device utilization.

SJF (Shortest Job First) and Burst-Time Prediction

SJF theoretically gives the minimum average waiting time. The hard part is knowing how long the next CPU burst will be.

Operating systems usually use historical data and exponential averaging to predict the next burst length:

$\tau_{n+1} = \alpha t_n + (1-\alpha)\tau_n$

• $t_n$: the actual length of the $n$-th CPU burst.
• $\tau_n$: the predicted value for the $n$-th burst.
• $\alpha$: the weight coefficient, often set to 1/2, determining how much recent history affects the prediction.

RR (Round Robin)

Designed for time-sharing systems. Each process receives a time quantum $q$, usually 10 to 100 milliseconds.

• Core constraint: the time quantum $q$ must be much larger than context-switch time, which is usually less than 10 microseconds. If $q$ is too small, most CPU time is wasted on context-switch overhead.

Multilevel Feedback Queue

This is the most complex but also the most general algorithm. It allows processes to move among multiple queues according to runtime behavior. A multilevel feedback queue scheduler needs these parameters:

• The number of queues.
• The scheduling algorithm inside each queue, for example RR at the top level and FCFS at the bottom.
• The method for promoting a process to a higher-priority queue, such as aging.
• The method for demoting a process to a lower-priority queue, such as using up its time quantum.
• The method for deciding which queue a process enters initially.

3. Thread Scheduling

In systems that support threads, the actual scheduling unit is the thread. There are two contention scopes:

• PCS (Process Contention Scope): the thread library schedules threads in user space, and threads within the same process compete with each other.
• SCS (System Contention Scope): the operating-system kernel directly schedules kernel-level threads onto logical CPUs, and all threads in the system compete with each other.

In the POSIX API (pthread), programmers can specify the contention scope using PTHREAD_SCOPE_PROCESS or PTHREAD_SCOPE_SYSTEM, but the final result depends on OS support. Linux and macOS support only SCS.

4. Advanced Multiprocessor and Multicore Scheduling

Modern Hardware Architecture

• Physical Core: a real independent processing unit on the chip.
• Logical CPU: the execution unit seen by the OS when hardware multithreading, such as hyper-threading, is supported.
• Two-level scheduling model:
  • Level 1 (OS layer): decides which software thread runs on which logical CPU.
  • Level 2 (hardware layer): the physical core automatically switches which hardware thread to execute based on memory stalls, filling gaps while waiting for data.

Multicore Architecture and Memory Stalls

Modern CPUs often stall while waiting for memory data. To make use of these stall cycles, processors use hardware multithreading, such as hyper-threading. When one hardware thread experiences a memory stall, the physical core can quickly switch to executing instructions from another hardware thread.

NUMA Awareness

In Non-Uniform Memory Access (NUMA) architectures, a CPU accesses local memory much faster than remote memory.

NUMA-aware scheduling: when scheduling, the operating system should not only allocate CPU time but also assign processes to processor domains whose memory nodes are closest to that CPU, reducing migration across physical nodes.

5. Mathematical Constraints in Real-Time CPU Scheduling

Real-time systems handle periodic tasks. These tasks have three core parameters:

• $t$: processing time
• $d$: deadline
• $p$: period

Constraint: $0 \le t \le d \le p$. The task execution rate is $1/p$.

Core Logic of Two Real-Time Algorithms

• RMS (Rate-Monotonic Scheduling): static priority. Priority is determined by the reciprocal of the period. Shorter period means higher priority. Its drawback is that when CPU utilization is high, it cannot guarantee that every process meets its deadline.
• EDF (Earliest Deadline First): dynamic priority. The system always checks which task has the nearest deadline, and that task immediately receives the highest priority.
• POSIX real-time standard: defines SCHED_FIFO, a FIFO policy without time slicing, and SCHED_RR, a round-robin policy with time slicing.

6. Scheduler Implementations in Three Major Operating Systems

Linux CFS (Completely Fair Scheduler)

• Core idea: instead of allocating fixed time slices, allocate proportions of CPU usage.
• vruntime (virtual runtime): records actual task runtime. It is scaled by the task’s Nice value, from -20 to +19. Tasks with lower Nice values, hence higher priority, have slower-growing vruntime and therefore receive more real CPU time.
• Data structure: runnable tasks are stored in a Red-Black Tree keyed by vruntime. The scheduler always selects the leftmost node, namely the node with the smallest vruntime, with $O(\log N)$ time complexity.

Windows (Preemptive Priority Scheduling)

• Priority system: 32 levels. Levels 1-15 are variable priorities for normal programs, levels 16-31 are real-time priorities, and level 0 is reserved for memory management.
• Dynamic boost mechanism: when an event a thread is waiting for completes, especially foreground keyboard I/O, Windows gives the thread a large priority boost. The foreground active window also receives three times the time quantum.
• UMS (User-Mode Scheduling): allows applications to manage a large number of concurrent threads independently of the kernel, greatly improving the efficiency of C++ concurrency frameworks.

Solaris (A Peak Application of Multilevel Feedback Queues)

Solaris’s default time-sharing (TS) scheduler uses a complex Dispatch Table to achieve balance through state transitions:

• Time quantum expired penalty: if a process uses up its entire time quantum, indicating that it is compute-intensive, it is moved to a lower priority, but receives a longer time quantum next time.
• Return from sleep reward: if a process gives up the CPU early to wait for I/O, indicating interactivity, it is promoted to a higher priority when it wakes up and receives a shorter time quantum.

7. Algorithm Evaluation Models

To evaluate which scheduling algorithm best fits an operating system, common methods include:

• Queueing Models: describe the computer as a network of servers and use probability theory to compute steady-state performance. The most famous result is Little’s Law: $n = \lambda \times W$ (average queue length $n$ = average arrival rate $\lambda$ $\times$ average waiting time $W$ in the queue)
• Simulations: build a model of the computer system through programming, then use real system event logs, called trace tapes, as input to drive the simulation and obtain highly accurate performance statistics.

1. 核心概念与分派机制

CPU-I/O 爆发周期 (Burst Cycle)

进程的执行并非一直占用 CPU，而是由 CPU 爆发 (CPU burst) 和 I/O 爆发 (I/O burst) 交替组成。 通过对大量进程的统计发现：系统中存在海量的短 CPU 爆发进程，和极少量的长 CPU 爆发进程。这一分布规律是设计调度算法的重要依据。

分派器与分派延迟 (Dispatcher & Dispatch Latency)

分派器是实际执行“切换”动作的模块。分派延迟是指停止一个进程并启动另一个进程所需的时间。 在要求严格的系统中，分派延迟中的冲突阶段 (Conflict phase) 是主要瓶颈，它包括两步：

1. 抢占在内核模式下运行的任何进程。
2. 低优先级进程释放高优先级进程所需的系统资源。

2. 核心调度算法深度解析

FCFS (先来先服务)

• 痛点：护送效应 (Convoy effect)。如果一个 CPU 密集型的长进程排在前面，后面一群 I/O 密集型的短进程只能被迫长时间等待，导致整体 CPU 和 I/O 设备利用率双双下降。

SJF (短作业优先) 与爆发时间预测

SJF 在理论上能给出最小的平均等待时间。难点在于如何知道进程的下一个 CPU 爆发会有多长。 操作系统通常利用历史数据，通过指数平均法 (Exponential Averaging) 来预测下一个爆发长度： $\tau_{n+1} = \alpha t_n + (1-\alpha)\tau_n$

• $t_n$：第 $n$ 次实际的 CPU 爆发长度。
• $\tau_n$：对第 $n$ 次的预测值。
• $\alpha$：权重系数（通常设为 1/2），决定了近期历史数据对预测值的影响程度。

RR (时间片轮转)

专门为分时系统设计，给予每个进程一个时间片 $q$（通常 10-100 毫秒）。

• 核心约束：时间片 $q$ 必须远大于上下文切换的时间（通常 < 10 微秒）。如果 $q$ 太小，CPU 的大部分时间都会浪费在上下文切换的开销上。

多级反馈队列 (Multilevel Feedback Queue)

这是最复杂但也最通用的算法。它允许进程根据其运行行为在多个队列之间移动。定义一个多级反馈队列调度器需要设定以下详细参数：

• 队列的数量。
• 每个队列内部的调度算法（例如顶层用 RR，底层用 FCFS）。
• 决定何时将进程升级到高优先级队列的方法（例如老化机制）。
• 决定何时将进程降级到低优先级队列的方法（例如用光了时间片）。
• 决定进程初始进入时被放入哪个队列的方法。

3. 线程调度 (Thread Scheduling)

在支持线程的系统中，实际调度的单位是线程。存在两种竞争范围：

• PCS (进程竞争范围)：由线程库在用户态进行调度，同一进程内的线程相互竞争。
• SCS (系统竞争范围)：由操作系统内核直接将内核级线程调度到逻辑 CPU 上，全系统的线程相互竞争。

在 POSIX API (pthread) 中，程序员可以通过 PTHREAD_SCOPE_PROCESS 或 PTHREAD_SCOPE_SYSTEM 来指定竞争范围，但最终取决于操作系统的支持（如 Linux 和 macOS 仅支持 SCS）。

4. 多处理器与多核调度进阶

现代硬件架构

• 物理核心 (Physical Core)：芯片上真实的独立处理单元。
• 逻辑 CPU (Logical CPU)：支持硬件多线程（如超线程）时，OS 看到的执行单元。
• 两级调度模型：
  • 第一级 (OS层)：决定哪个软件线程在哪个逻辑 CPU 上运行。
  • 第二级 (硬件层)：物理核心根据内存停顿 (Memory Stall) 自动切换执行哪个硬件线程，以填补等待数据的空隙。

多核架构与内存停顿 (Memory Stall)

现代 CPU 往往由于等待访问内存数据而发生停顿。为了利用这些停顿周期，处理器采用硬件多线程（如超线程）。当一个硬件线程发生内存停顿时，物理核心可以迅速切换去执行另一个硬件线程的指令。

NUMA 系统感知

在非一致性内存访问 (NUMA) 架构中，CPU 访问本地内存的速度远快于访问远程内存。 NUMA 感知调度：操作系统在调度时，不仅要分配 CPU，还要将进程分配给拥有离该 CPU 最近的内存节点的处理器域 (Domain)，尽量避免线程在不同物理节点间迁移。

5. 实时 CPU 调度的数学约束

实时系统处理的是周期性任务。这些任务具有三个核心参数：

• $t$：处理时间 (Processing time)
• $d$：截止时间 (Deadline)
• $p$：周期 (Period) 约束条件：$0 \le t \le d \le p$。任务的执行速率即为 $1/p$。

两种实时算法的核心逻辑

• RMS (速率单调调度)：静态优先级。优先级由周期的倒数决定。周期越短优先级越高。缺点是当 CPU 利用率较高时，无法保证所有进程不漏掉 Deadline。
• EDF (最早交期优先)：动态优先级。系统时刻检查哪个任务的截止时间最迫近，最迫近的任务立即获得最高优先级。
• POSIX 实时标准：定义了 SCHED_FIFO（先进先出无时间片）和 SCHED_RR（带时间片轮转）两种硬性调度策略。

6. 三大操作系统调度器底层实现

Linux CFS (完全公平调度器)

• 核心思想：不分配固定的时间片，而是分配 CPU 的使用比例。
• vruntime (虚拟运行时间)：记录任务实际运行时间。基于任务的 Nice 值（-20 到 +19）设有衰减因子。低 Nice 值（高优先级）的任务，其 vruntime 增长得慢，从而能获得更多的 CPU 实际时间。
• 数据结构：采用红黑树 (Red-Black Tree) 存储可运行任务，键值为 vruntime。调度器总是取树最左侧的节点（即 vruntime 最小的节点）执行，时间复杂度为 $O(\log N)$。

Windows (抢占式优先级调度)

• 优先级体系：共 32 级。1-15 级为可变优先级（普通程序），16-31 级为实时优先级，0 级保留给内存管理。
• 动态提升机制：当线程等待的事件完成时（尤其是键盘 I/O 等前台交互），Windows 会给予巨大的优先级提升奖励；同时，前台活动窗口会获得 3 倍的时间片调度量。
• UMS (用户模式调度)：允许应用程序独立于内核管理大量并发线程，大幅提高 C++ 并发框架的效率。

Solaris (多级反馈队列的巅峰应用)

Solaris 的默认分时 (TS) 调度采用了一个复杂的分派表 (Dispatch Table)，通过状态转换来实现完美平衡：

• 时间片耗尽惩罚 (Time quantum expired)：如果进程一口气用完了时间片（说明是计算密集型），会被丢到低优先级，但下次分配长时间片。
• 睡眠唤醒奖励 (Return from sleep)：如果进程提前放弃 CPU 去等待 I/O（说明是交互型），唤醒时会被提升到高优先级，并分配短时间片。

7. 算法评估模型

评估哪种调度算法最适合当前操作系统，通常采用以下方法：

• 排队模型 (Queueing Models)：将计算机描述为服务器网络，利用概率论计算稳态性能。最著名的是 利特尔法则 (Little’s Law)： $n = \lambda \times W$ (平均队列长度 $n$ = 平均到达率 $\lambda$ $\times$ 队列中的平均等待时间 $W$)
• 模拟 (Simulations)：通过编程建立计算机系统的模型，并使用真实的系统事件日志——跟踪磁带 (Trace tapes) 作为输入数据来驱动模拟，从而获得高度精确的性能统计。

LaTeX Tutorial

1. Basic Syntax

1.1 Document Structure

\documentclass{article}  % Document type
\usepackage{amsmath}     % Math package
\usepackage{amssymb}     % Math symbol package

\begin{document}
% Document content
\end{document}

1.2 Text Formatting

\textbf{bold text}        % Bold
\textit{italic text}      % Italic
\underline{underline}     % Underline
\texttt{monospace text}   % Typewriter font

2. Math Mode

2.1 Inline and Display Formulas

Inline formula: $E = mc^2$
Display formula: $$E = mc^2$$
Or:
\[ E = mc^2 \]

2.2 equation Environment

\begin{equation}
  E = mc^2
\end{equation}

% Without numbering
\begin{equation*}
  E = mc^2
\end{equation*}

3. Common Mathematical Symbols

3.1 Greek Letters

Lowercase letters:

\alpha    α       \beta     β       \gamma    γ
\delta    δ       \epsilon  ε       \zeta     ζ
\eta      η       \theta    θ       \iota     ι
\kappa    κ       \lambda   λ       \mu       μ
\nu       ν       \xi       ξ       \pi       π
\rho      ρ       \sigma    σ       \tau      τ
\upsilon  υ       \phi      φ       \chi      χ
\psi      ψ       \omega    ω

Uppercase letters:

\Gamma    Γ       \Delta    Δ       \Theta    Θ
\Lambda   Λ       \Xi       Ξ       \Pi       Π
\Sigma    Σ       \Upsilon  Υ       \Phi      Φ
\Psi      Ψ       \Omega    Ω

3.2 Operators

Basic operations:

+         plus    -         minus   \times    ×
\div      ÷       \pm       ±       \mp       ∓
\cdot     ·       \ast      *       \star     ⋆

Relational operators:

=         =       \neq      ≠       <         <
>         >       \leq      ≤       \geq      ≥
\ll       ≪       \gg       ≫       \approx   ≈
\equiv    ≡       \sim      ∼       \simeq    ≃
\propto   ∝       \in       ∈       \notin    ∉
\subset   ⊂       \subseteq ⊆       \supset   ⊃

Logical symbols:

\land     ∧       \lor      ∨       \neg      ¬
\implies  ⟹       \iff      ⟺       \forall   ∀
\exists   ∃       \nexists  ∄       \emptyset ∅

3.3 Superscripts and Subscripts

x^2              % Superscript
x_i              % Subscript
x^{2y}           % Multi-character superscript
x_{ij}           % Multi-character subscript
x_i^2            % Superscript and subscript together

3.4 Fractions and Roots

\frac{a}{b}      % Fraction
\dfrac{a}{b}     % Display-style fraction
\tfrac{a}{b}     % Text-style fraction
\sqrt{x}         % Square root
\sqrt[n]{x}      % n-th root

3.5 Summation, Integrals, and Limits

\sum_{i=1}^{n}          % Summation
\prod_{i=1}^{n}         % Product
\int_{a}^{b}            % Integral
\iint                   % Double integral
\iiint                  % Triple integral
\oint                   % Contour integral
\lim_{x \to \infty}     % Limit

3.6 Brackets

()                       % Parentheses
[]                       % Square brackets
\{\}                     % Braces
\langle \rangle          % Angle brackets
\lfloor \rfloor          % Floor
\lceil \rceil            % Ceiling

Automatic sizing:

\left( \frac{a}{b} \right)
\left[ \frac{a}{b} \right]
\left\{ \frac{a}{b} \right\}

4. Matrices

4.1 Basic Matrices

% Matrix without brackets
\begin{matrix}
  a & b \\
  c & d
\end{matrix}

% Parenthesized matrix
\begin{pmatrix}
  a & b \\
  c & d
\end{pmatrix}

% Square-bracket matrix
\begin{bmatrix}
  a & b \\
  c & d
\end{bmatrix}

% Brace matrix
\begin{Bmatrix}
  a & b \\
  c & d
\end{Bmatrix}

% Single-vertical-line matrix
\begin{vmatrix}
  a & b \\
  c & d
\end{vmatrix}

% Double-vertical-line matrix
\begin{Vmatrix}
  a & b \\
  c & d
\end{Vmatrix}

4.2 Ellipses

\dots    % Low ellipsis
\cdots   % Centered ellipsis
\vdots   % Vertical ellipsis
\ddots   % Diagonal ellipsis

5. Multi-Line Formulas

5.1 align Environment

\begin{align}
  x &= a + b \\
  y &= c + d \\
  z &= e + f
\end{align}

5.2 cases Environment

f(x) = \begin{cases}
  x^2 & \text{if } x \geq 0 \\
  -x  & \text{if } x < 0
\end{cases}

5.3 split Environment

\begin{equation}
\begin{split}
  f(x) &= (x+1)^2 \\
       &= x^2 + 2x + 1
\end{split}
\end{equation}

6. Special Symbols

6.1 Arrows

\rightarrow  →       \leftarrow   ←
\Rightarrow  ⇒       \Leftarrow   ⇐
\leftrightarrow ↔    \Leftrightarrow ⇔
\uparrow     ↑       \downarrow   ↓
\Uparrow     ⇑       \Downarrow   ⇓
\mapsto      ↦       \longmapsto  ⟼
\longrightarrow ⟶    \Longrightarrow ⟹

6.2 Other Common Symbols

\infty       ∞       \partial     ∂
\nabla       ∇       \hbar        ℏ
\prime       ′       \ldots       …
\cdots       ⋯       \vdots       ⋮
\ddots       ⋱       \angle       ∠
\degree      °       \circ        ∘
\bullet      •       \cap         ∩
\cup         ∪       \triangle    △

6.3 Fonts

\mathbb{R}          % Blackboard bold
\mathcal{A}         % Calligraphic
\mathfrak{A}        % Fraktur
\mathbf{A}          % Bold
\mathrm{A}          % Roman
\mathit{A}          % Italic
\mathsf{A}          % Sans-serif
\mathtt{A}          % Typewriter

7. Spacing Control

a\ b              % Normal space
a\,b              % Small space
a\:b              % Medium space
a\;b              % Large space
a\quad b          % 1em space
a\qquad b         % 2em space
a\!b              % Negative space

8. Text Comments

\text{text content}           % Insert text inside a formula
\mbox{text content}           % Text box

9. Accents

\hat{a}      â       \bar{a}      ā
\tilde{a}    ã       \dot{a}      ȧ
\ddot{a}     ä       \vec{a}      ā⃗
\widehat{ab}         \widetilde{ab}

10. Common Theorem Environments

\usepackage{amsthm}

\newtheorem{theorem}{Theorem}
\newtheorem{lemma}{Lemma}
\newtheorem{proposition}{Proposition}
\newtheorem{corollary}{Corollary}
\newtheorem{definition}{Definition}

\begin{theorem}
  Theorem content
\end{theorem}

\begin{proof}
  Proof content
\end{proof}

11. Common Tips

11.1 Alignment

\begin{aligned}
  &\text{left aligned} \\
  &\text{content}
\end{aligned}

11.2 Numbering Control

\tag{1}              % Manual tag
\notag               % Remove numbering
\nonumber            % Remove numbering

11.3 Colors

\usepackage{xcolor}
\textcolor{red}{red text}
\colorbox{yellow}{yellow background}

12. Best Practices

1. Matching brackets: use \left and \right to automatically adjust bracket size.
2. Long formulas: use align or split to break lines.
3. Matrices: choose an appropriate bracket type.
4. Spacing: use \,, \quad, and similar commands to adjust spacing.
5. Text: use \text{} to insert text in formulas.
6. Symbols: define macros for complex symbols to simplify input.

% Custom command examples
\newcommand{\R}{\mathbb{R}}
\newcommand{\norm}[1]{\left\| #1 \right\|}

References

• Overleaf Documentation
• LaTeX Wikibook
• Detexify - handwritten LaTeX symbol recognition