<?xml version="1.0" encoding="utf-8"?><feed xmlns="http://www.w3.org/2005/Atom" xml:lang="zh-CN"><generator uri="https://jekyllrb.com/" version="3.10.0">Jekyll</generator><link href="https://blog.unicornt.cn/feed.xml" rel="self" type="application/atom+xml" /><link href="https://blog.unicornt.cn/" rel="alternate" type="text/html" hreflang="zh-CN" /><updated>2026-07-17T10:18:22+08:00</updated><id>https://blog.unicornt.cn/feed.xml</id><title type="html">unicornt的博客</title><subtitle>欢迎来到unicornt的博客
</subtitle><author><name>unicornt</name><email>unicorntwin@outlook.com</email></author><entry><title type="html">OS-report01</title><link href="https://blog.unicornt.cn/2021/01/14/OS-Report01.html" rel="alternate" type="text/html" title="OS-report01" /><published>2021-01-14T00:00:00+08:00</published><updated>2021-01-14T00:00:00+08:00</updated><id>https://blog.unicornt.cn/2021/01/14/OS-Report01</id><content type="html" xml:base="https://blog.unicornt.cn/2021/01/14/OS-Report01.html"><![CDATA[<!--more-->
<h2 id="我所理解的操作系统">我所理解的操作系统</h2>

<p>​	操作系统是一个软件的集合，目的是为了为用户提供一个安全可靠并且高效的软件运行环境。作为第一个启动的软件，操作系统享有比其他软件更高的特权，从而为调度，运行，终止软件等等操作提供基础。不管是哪种宏内核，微内核，操作系统都要求对于硬件的敏感访问需要经过操作系统来完成，保证操作系统对与硬件的掌控。</p>

<p>​	操作系统的<strong>一部分</strong>作用就像 IDE（集成开发环境）对于编程者一样。IDE可以将代码的编译，链接等等隐藏起来，仅仅给用户一个简单的编写代码界面和一个“运行”按钮。完成代码之后只需要点一下这个按钮，代码就可以编译运行。操作系统也是如此，将各种硬件资源（CPU，内存等等）抽象出来，为用户提供使用的接口，让用户程序在使用硬件的时候不需要过多考虑硬件层面的问题。与此同时，屏蔽了用户对硬件的大部分直接访问，对于硬件来说也是一种保护，将硬件的细节隐藏起来，也让操作系统能在用户看不见的地方进行对硬件的运行优化，提高软件运行的效率，最大程度上应用硬件的能力。</p>

<p>​	但是操作系统的作用绝不仅限于此。操作系统需要在多个进程的竞争之间进行协调并且保证自己的特权。操作系统对硬件进行复用来实现对多个进程的并发运行，这使得操作系统可以在同时服务多个用户的情况下，让每个用户都觉得自己独占了一台计算机。并发运行的意义绝不仅仅在于提供多用户的功能（当然这个功能也非常重要），并发运行可以有效并行不同的程序，从而大大提高 CPU 的占用率，减少CPU 空转时间。让“高速”的 CPU 和“低速”的硬件之间能够同时运行，或者说最大程度上同时运行。</p>

<p>​	为了确保操作系统能够维持住自己的特权，操作系统需要定期中断正在运行的程序，因此有分时系统的出现。分时系统与其说是确保了操作系统能够维护住自己的特权，不如说是为应用完全占用硬件提供了基础。有了分时系统，操作系统才能“放心”让应用完全占用计算机，而不是采用虚拟机的方式，为应用提供虚拟的硬件。这对于计算机效率的提高有着非常重大的意义。</p>

<p>​	在一台机器上同时运行多个进程为计算机提供了同时服务多个用户的功能和对硬件的高效利用，而另一方面，操作系统在硬件和用户之间抽象出了一层，极大增加了应用的可移植性。在我看来，这就是操作系统的两个主要作用。</p>

<h2 id="未来操作系统的形态">未来操作系统的形态</h2>

<p>​	操作系统在未来发展的最大需求来自硬件和应用两个方面的压力。</p>

<p>​	在硬件方面，未来计算机的内存大小，内核数量等都会有显著的扩张。</p>

<p>​	内存方面，大量的异构计算将导致内存的高度分散化，与此同时，单内核能够访问的内存将进一步扩大。内存的扩大很可能导致虚拟内存的消亡，但也需要支持应用对物理内存的访问。不仅如此，内存管理的方式也亟需改进，需要更加贴近内存以实现各种功能性的优化。内核方面，现代操作系统的单个宏内核体系很有可能在内核数量达到一定程度时出现频繁的错误，这要求操作系统向分布式发展。分布式操作系统的设计带来的挑战不仅有通信问题，还有进程调度的问题。</p>

<p>​	在应用方面，云服务的流行也为操作系统的设计提出了新的要求。</p>

<p>​	云服务对操作系统安全性和权限的要求更进一步。由于云服务可能由上千万个用户同时运行，应用本身就是分布式的，操作系统需要提供细粒度的授权机制以及大规模控制分布式信息流的功能。</p>

<p>​	总的来说，未来操作系统主要解决的问题就是来自硬件和应用两方面对于分布式的要求。尽管现在不论是基于当前操作系统开发的软件数量还是用户数量，都已经十分庞大，似乎很难动摇当前操作系统的根基。但是实际上很多应用并不是直接使用操作系统提供的API，而是更加高一级的API，所以操作系统的更新换代也许没有想象中的阻碍那么大。尽管如此，仍有很多除了技术之外的原因会对操作系统的更替产生影响。因此，我认为，新体系的操作系统的出现可能很快出现，但是这个操作系统的普及可能比计算机的普及更加困难。但是考虑到上述需求短时间内只需要在服务器端满足即可，新操作系统在个人计算机中的普及也并非燃眉之急。</p>]]></content><author><name>unicornt</name><email>unicorntwin@outlook.com</email></author><category term="OS-report" /><summary type="html"><![CDATA[]]></summary></entry><entry><title type="html">OS-report02</title><link href="https://blog.unicornt.cn/2021/01/14/OS-Report02.html" rel="alternate" type="text/html" title="OS-report02" /><published>2021-01-14T00:00:00+08:00</published><updated>2021-01-14T00:00:00+08:00</updated><id>https://blog.unicornt.cn/2021/01/14/OS-Report02</id><content type="html" xml:base="https://blog.unicornt.cn/2021/01/14/OS-Report02.html"><![CDATA[<p>​	<em>Inside the Linux 2.6 Completely Fair Scheduler</em> 阅读报告</p>

<!--more-->

<h2 id="概述">概述</h2>

<p>​	CFS 全称 Completely Fair Scheduler，也就是完全公平调度器。CFS 是 Linux 内核的一部分，负责对进程的调度。在 CFS 投入使用之前，Linux 内核曾经使用过队列，O(1) 调度器作为内核的默认调度器。</p>

<p>​	CFS 的目标就是对进程进行公平的调度，保证每个进程能够持有公平数量的占用处理器的时间。为了达到这个目的，CFS 引入了虚拟时间和衰退因数的概念来取代优先级。同时，维护一棵红黑树来进行加入任务，取出下一个调度的任务等操作，由于红黑树上的操作复杂度是 $O(\log n)$ ，因此 CFS 的效率非常优秀。</p>

<h2 id="结构">结构</h2>

<p>​	CFS 定义了 sched_entity 类来作为 task_struct 的成员以追踪任务信息。sched_entity 包括 rb_node 类，rb_node 类用来维护红黑树上当前任务对应的节点，记录父节点颜色，左右子节点信息。整棵树的根节点储存在 cfs_rq（CFS ready queue）类中。通过 cfs_rq 就可以遍历整棵红黑树。</p>

<p>​	整棵红黑树满足：左子节点任务的虚拟时间 $\le$ 该节点任务的虚拟时间 $\le$ 右子节点任务的虚拟时间。因此要找到虚拟时间最小的节点，只需要向左遍历到叶节点。</p>

<h2 id="调度方式">调度方式</h2>

<p>​	在可以发生抢占或者当前运行任务主动放弃处理器的时候，调度器只需要调用 schedule() 函数，找到造成抢占的任务。当前任务返回红黑树（如果进程是主动放弃处理器，需要直接从 cfs_rq 中删除不用返回红黑树）调用 pick_next_task() 来找到当前虚拟时间最小的节点，通过调用 task_of() 函数找到对应的任务，并将任务提供给处理器进行运行。</p>

<p>​	CFS 采用虚拟时间而非真实时间的目的就是引入衰退因数作为优先级的替代品。衰退因数和任务的优先级有关，优先级高的任务衰退因数较小，反之衰退因数比较大。衰退因数与程序运行时虚拟时间的增长速度的成正比，也就是衰退因数越小，虚拟时间的增长越慢，程序越慢被抢占，直观上非常符合我们对于优先级的定义。同时也可以发现，因为虚拟时间很大程度上受衰退因数影响，调度器对于任务具体运行时间是没有概念的。</p>

<p>​	采用虚拟时间和衰退因数的好处在于不需要为每个优先级都建立一个队列，也不需要遍历每个任务来找到下一个运行的任务，在 $O(n)$ 和 $O(1)$ 的调度器之间做了一个折中。</p>

<h2 id="成组调度">成组调度</h2>

<p>​	如果在单独任务的调度上，CFS 并没有给我非常直观的”完全公平“感受，成组调度可以说是非常好的诠释了”公平调度“的理念。对于形如一个服务派生出许多任务来进行并行处理的情况，显然把每个任务都相同对待是不公平（或者叫不完全公平？）的，但是如果采用传统的设定优先级的方法给每个任务设置低优先级，对于这个服务又不公平。CFS 引入了成组调度的概念，派生出任务的服务进程跨进程共享虚拟时间。</p>

<p>​	不仅仅是公平方面，成组调度对于需要合作的任务有很大好处。需要合作的任务可以共同获得处理器的控制权，减少因为同步而造成的阻塞，减少了上下文切换的成本。</p>

<h2 id="总结">总结</h2>

<p>​	CFS 为 Linux 内核提供了一个兼顾高效和易操控性的进程调度器。每次 $O(\log n)$ 的操作相比简单的遍历更加高效，而虚拟时间和衰退因数的引入避免了多个任务队列的需要，让整个调度器更加容易操控。CFS 也为成组调度提供了一个简单的方法。相比于之前的 Linux 调度器，CFS 更加能够适应进程数增加的趋势。</p>]]></content><author><name>unicornt</name><email>unicorntwin@outlook.com</email></author><category term="OS-report" /><summary type="html"><![CDATA[​ Inside the Linux 2.6 Completely Fair Scheduler 阅读报告]]></summary></entry><entry><title type="html">OS-report03</title><link href="https://blog.unicornt.cn/2021/01/14/OS-Report03.html" rel="alternate" type="text/html" title="OS-report03" /><published>2021-01-14T00:00:00+08:00</published><updated>2021-01-14T00:00:00+08:00</updated><id>https://blog.unicornt.cn/2021/01/14/OS-Report03</id><content type="html" xml:base="https://blog.unicornt.cn/2021/01/14/OS-Report03.html"><![CDATA[<p>页面着色和局部性原理</p>

<!--more-->

<h2 id="页面着色">页面着色</h2>

<h3 id="原理">原理</h3>

<p>​	页面着色的出现，是为了解决虚拟内存中相邻的页表，因为在物理地址上不相邻，（可能）导致出现 cache 出现大量缺页，从而造成抖动。</p>

<p><img src="Report03_18307130104_%E8%B5%B5%E6%96%87%E8%BD%A9.assets/qvsns.jpg" alt="cache" /></p>

<p>​	cache 的设计采用中间一段地址作为 Set 的寻址。采用 Set 作为索引不仅保证了相邻的物理内存可以整块出现在 cache 中，是局部性原理的体现，而且保证了物理内存中相邻的块不会出现在同一个 cache set 中产生冲突。但是从虚拟内存到物理内存中，可能导致相邻虚拟地址的内存块被影射到不相邻的内存块中，而更加致命的是，可能会映射到 Set 相同的物理地址，从而导致相邻的虚拟地址对相同的 cache set 进行竞争。这显然和局部性原理以及 cache 的设计初衷相违背的。</p>

<p>​	而页面着色的设计，正是为了解决虚拟内存的出现给 cache 带来的问题。通过竞争产生机制的分析，可以发现关键在于虚拟内存映射到物理内存的映射。如果能够保证相邻的虚拟内存不会映射到相同 Set index 的物理内存上，就不会产生这种竞争。因此会从 Set index 中选择一些 bits 作为 color bits，在操作系统为虚拟内存分配页表的时候，可以进行优化，选择将相邻的虚拟地址映射到不同 color bits 的页表中。虚拟地址由操作系统来维护，将这个操作交给操作系统再合适不过了。</p>

<h3 id="应用">应用</h3>

<p>​	page coloring 技术被应用在 Solaris，FreeBSD，NetBSD，WindowsNT等操作系统中，虽然大大增加了操作系统的复杂性，但是对于性能的优化也是可观的。</p>

<h2 id="局部性原理">局部性原理</h2>

<p>​	局部性原理是计算机中广泛出现的一个现象。局部性原理表明了资源在时间和空间上的聚集性，不仅仅在操作系统中，也在硬件设计，网络，软件等方面有着广泛的应用。</p>

<p>局部性原理可以分为两个方面：</p>

<ol>
  <li>
    <p>时间层面的局部性，即对于同一个资源的引用会在一段时间内大量出现。</p>
  </li>
  <li>
    <p>空间层面的局部性，即相邻的资源很有可能被同时引用。</p>
  </li>
</ol>

<p>通过对局部性原理的运用，有以下好处：</p>

<ol>
  <li>
    <p>进行计算时只需要加载当前所用到的部分资源而非所有资源，这对于缓存器（比如 cache）的容量要求大大降低。</p>
  </li>
  <li>
    <p>同一工作集中的资源可以被同时加载，加速后面的计算。</p>
  </li>
  <li>
    <p>如果不知道接下来运用的资源，就保持已经加载的资源不变。</p>
  </li>
</ol>

<p>可以看到，局部性原理对于计算整个流程的资源加载都有着指导意义，帮助操作系统选择最优的行动。</p>

<p>不仅仅对现代操作系统，局部性原理在很多其他系统上也有着重要作用，</p>

<p><img src="Report03_18307130104_%E8%B5%B5%E6%96%87%E8%BD%A9.assets/image-20201106102646269.png" alt="locality in different systems" /></p>

<p>如上图所示，局部性原理可以通过数据的来源和使用方向分成四类。</p>

<ol>
  <li>
    <p>内部数据内部使用。比如网购网站可以通过用户购买或浏览的记录，预测后来的用户可能感兴趣的物品。</p>
  </li>
  <li>
    <p>内部数据外部使用。比如链接器找到源代码引用的库文件作为源程序的工作集。</p>
  </li>
  <li>
    <p>外部数据内部使用。比如搜索引擎通过对网页数据的整理为用户的请求提供相关的信息。</p>
  </li>
  <li>
    <p>外部数据外部使用。比如虚拟内存系统计算工作集保证为程序提供足够的空间。</p>
  </li>
</ol>

<p>局部性原理从操作系统的应用到更多系统的应用，展示了这个原理的广泛性，不仅仅是在计算机的资源加载中，在人类的行为等等方面也具有重要意义。相信未来局部性原理能够在更多领域获得运用。</p>]]></content><author><name>unicornt</name><email>unicorntwin@outlook.com</email></author><category term="OS-report" /><summary type="html"><![CDATA[页面着色和局部性原理]]></summary></entry><entry><title type="html">OS-report04</title><link href="https://blog.unicornt.cn/2021/01/14/OS-Report04.html" rel="alternate" type="text/html" title="OS-report04" /><published>2021-01-14T00:00:00+08:00</published><updated>2021-01-14T00:00:00+08:00</updated><id>https://blog.unicornt.cn/2021/01/14/OS-Report04</id><content type="html" xml:base="https://blog.unicornt.cn/2021/01/14/OS-Report04.html"><![CDATA[<p>并发理论内存模型的修改
<!--more--></p>

<h2 id="文章内容">文章内容</h2>

<p>​	作者认为，并发理论需求一个全新的概念框架，而不是仅仅在现有框架上的革新。</p>

<p>​	考虑一列相继运行的程序，假设没有任何的即刻输出，可以被表示成一个读入内存输出内存的函数，程序的含义可以被定义为内存-&gt;内存。而并发运行强制引入了不确定性的概念。对此，定义 P(D) 为里面的元素是D的子集，重新定义程序为 内存-&gt;P(内存)。</p>

<p>​	但是并发的出现导致的另一个问题是组成性的丧失，也就是合并子程序并发运行时，会产生不同的结果。因此，这个概念还需要改进，重新考虑程序和内存的交互。为此，作者用 4 张图展示了程序与内存交互模型的变化。</p>

<p>Figure.1: 最基础的模型，有积极/消极的区别，程序时积极的一方，内存是消极的一方。</p>

<p><img src="img/image-20201122213304752.png" alt="Figure.1" style="zoom:67%;" /></p>

<p>Figure.2: 将M视作进程的状态，将变量视作程序和内存交换通道的名字。</p>

<p><img src="img/image-20201122213324430.png" alt="Figure.2" style="zoom:67%;" /></p>

<p>但是将内存视作一块的想法在并发时不能成立，因为不同部分的内存可能被同时访问，因此有了下面的改进。</p>

<p>Figure.3: 将不同部分的内存视作分布式进程</p>

<p><img src="img/image-20201122213346411.png" alt="Figure.3" style="zoom: 67%;" /></p>

<p>Figure.4: 为了破除进程是交互发起者的印象，采用了汽车接收广播信号的模型。汽车可以在附近的广播站提供的频道进行切换，而所有的广播站由中央统一管理。</p>

<p><img src="img/image-20201122213404256.png" alt="Figure.4" style="zoom: 67%;" /></p>

<p>​	文章主要的思想就是如何破除传统的观念，将内存和程序视作同一种元素，而非主仆关系，从而为之后的并发模型进行铺垫。</p>

<h2 id="我的理解">我的理解</h2>

<p>​	谈谈我对这四张图片中包含意思的理解。</p>

<p>​	图片1 是我们传统编程中对于内存和程序的概念，也就是程序主动访问内存，内存在等待程序的访问。为了破除这样的观念，将内存和程序拉到一个平等的地位上来，就形成了图片2所示的模型。</p>

<p>​	图片2 将程序和内存放在了一个平等的位置上，将变量视作程序和内存的通信，变量名就是通道的名字，变量的值通过通道传输到程序中。这样改变的好处是将内存融入到了整个模型中，内存不再是一个类似游戏贴图的东西了，而是真正变成了其中的一个模型。这就有利于对程序和内存关系的分析。但是实际上内存并非只能和一个程序交互，于是有了图片3 的改进。</p>

<p>​	图片3 将内存视作一个分布式的进程，能够同时和几个进程交互。可以说图片3 才算是和图片1 对等的一个模型。同时可以看到，对于多个程序对于相同内存块的竞争，变成了进程之间交互的竞争。</p>

<p>​	图片4 位了展现内存和进程之间的平等关系，类比了汽车的广播信号接收。</p>

<p>​	整个改变下来，对于如何处理并发问题有了很大的思路改变，就我阅读的想法来看，虽然我对并发理论一窍不通，但是这种改变却让我思考比如将内存访问改成服务等方法。可以说，文章开头说想要提出新的并发理论就要从内存模型上改变的话并不是空穴来风。</p>]]></content><author><name>unicornt</name><email>unicorntwin@outlook.com</email></author><category term="OS-report" /><summary type="html"><![CDATA[并发理论内存模型的修改]]></summary></entry><entry><title type="html">OS-report05</title><link href="https://blog.unicornt.cn/2021/01/14/OS-Report05.html" rel="alternate" type="text/html" title="OS-report05" /><published>2021-01-14T00:00:00+08:00</published><updated>2021-01-14T00:00:00+08:00</updated><id>https://blog.unicornt.cn/2021/01/14/OS-Report05</id><content type="html" xml:base="https://blog.unicornt.cn/2021/01/14/OS-Report05.html"><![CDATA[<p>事务性内存
<!--more--></p>

<h2 id="免费午餐的消失和事务性内存的出现">“免费午餐”的消失和事务性内存的出现</h2>

<p>​	事务性内存(Transactional Memory, 以下简称TM）试图以不（让编程者）加锁的方式解决并发问题。TM 的基本思路就是将程序视作读取和修改内存的事物，直接并发运行，利用冲突检测机制对可能发生的错误进行检测和修复。</p>

<p>​	随着多核架构的出现和普及，“免费午餐”不再有了，如果程序员想要利用好硬件性能的提升，就必须编写并行程序。然而编写并行程序并不像将程序复制一个新的备份一样简单，如何保证程序能够并行访问共享内存并且不出现错误是一个难题。</p>

<p>​	传统的解决办法就是锁机制。对临界区进行加锁，保证不会出现同时访问共享内存的情况，就破除了并发问题的“同时”因素。锁机制固然直白，带来的挑战也是巨大的。不恰当的加锁可能导致程序陷入死锁，乃至一系列问题。如果简单的加粗粒度锁，就无法从核心数量的进一步增加中获益（称作不可伸缩性）。如果希望程序正确而且可伸缩，就必须精细的添加细粒度锁，这对于程序员来说无疑是一个非常大的挑战，也是非常复杂的工作。</p>

<p>​	于是事务性内存便应运而生。事务一词从数据库的概念中借得，事务具有四点性质，被称作 ACID。</p>

<blockquote>
  <p>Atomic: 原子性，一个事务要么完全发生作用，要么完全没有作用。</p>

  <p>Consistency:  一致性，事务执行前后系统能够保持正确的状态。</p>

  <p>Isolation: 隔离性，事务之间相互隔离，在事务提交之前，事务内部的内存在外面是看不见的。</p>

  <p>Durability: 持续性，保证事务提交后对于系统的持续影响。</p>
</blockquote>

<p>​	ACID 大大简化了程序分析，在保证 ACID 的情况下，并行程序可能导致的一切并发问题都不复存在。原子性保证了类似普京打铁的问题不会出现，一致性保证了程序的正确性，隔离性延续了计算机中进程之间的隔离，持续性保证了程序对于内存的修改可以保存。而获得这些梦寐以求的性质只需要在原本的代码外加上一层诸如 atomic{} 之类的代码就可以完成。</p>

<p>​	可以看到，相比于锁机制，事务性内存更加易于使用，错误的处理更加简单。不仅如此，TM 保持了程序的可伸缩性和组合型，既保证了程序对于核心数的充分利用，也保证了程序进行组合后仍然保持这种性质。</p>

<h2 id="实现事务性内存的两个关键">实现事务性内存的两个关键</h2>

<p>​	然而问题没有被解决，只是被转移给了语言层面和硬件。实现 TM 的两个关键就是数据版本化控制和冲突检测。数据版本化是为了破坏并发问题的“共享”条件，每个事务对于内存的修改都会创建一个新的数据版本。</p>

<h3 id="数据版本维护">数据版本维护</h3>

<p>​	对于数据版本的维护有 eager 和 lazy 两种方法。顾名思义，eager versioning 会将写操作马上写入新版本，并将旧版本的数据缓存下来，如果事务退回，就将旧版本回复。与之相反的，lazy versioning 会将所有新版本的数据缓存知道事务结束，如果事务成功提交，就将缓存中的数据写入内存。内存的版本维护可以和 git 的版本维护类比，每个事务都可能开出一个新的分支，从而形成一个树状的结构，然后再收束成一个分支，完成开发。而对于 eager 和 lazy 两种方法的描述可以看出各个方法对于事务回退量的预估是不同的，这也引发我思考是不是可以像 CPU 的设计一样，进行类似分支预测的操作，选择当前事务的版本维护方法。</p>

<h3 id="冲突检测">冲突检测</h3>

<p>​	正如上面所述，可以把数据版本的维护看成是 git 的版本维护，那么想要完成开发，就需要合并所有的分支，而对分支的合并，冲突是在所难免的。显然程序运行中手动选择“采用当前修改”，“采用传入修改”，所以就需要对一些事务进行打回，也就是冲突检测。</p>

<p>​	冲突检测的关键在于追踪事务的读取和修改的内存集合。冲突检测可以分成两种：乐观（延迟）或悲观（及时）的冲突检测。乐观的冲突检测认为回退很少发生，所以仅仅再事务结束准备提交的时候进行冲突检测。虽然检测次数较少，但是可能导致大量事务的回退，并且和 eager versioning 不兼容。悲观的冲突检测认为回退经常发生，所以需要再每次事务进行读或写操作的时候进行检测，优点是亡羊补牢，为时不晚，缺点是可能会出现循环冲突导致所有的事务都不能提交（在乐观的冲突检测中是能够确保有一个版本可以提交成功的）。</p>

<p>​	由于乐观的冲突检测和 eager versioning 不兼容，所以如果还想搞分支预测那一套就只能选择 lazy versioning了。</p>

<p>​	TM 可能的组合一共有 3 种，如何进行选择也许不仅仅从语言设计者的层面（分支预测类似的机制），也可以交给程序的编写者来选择，这又是一个机制与策略分离的方向，语言设计者提供了三种机制，由程序编写者自行选择组合。<del>当然这只是我的想法，可能这三种机制根本不能被混用</del></p>

<p>​	与锁相似的，冲突检测也存在粒度的选择，分别有对象级，单元级，cache 级。只有对象级是语言层的处理方法，虽然更加靠近编程者的逻辑，但会导致错误检测到冲突。单元级能够有效减少错误检测，但是需要更多的空间和时间。cache 级在两种方法中做了折中。</p>

<p>​	可以看到，虽然 TM 的构想非常美好，实际上执行起来没有那么简单，不存在一个完美的方法保证性能，完美性和简便，实际使用中还需要对这些方面进行考量做出抉择，正所谓“没有银弹”。</p>

<h3 id="事务性内存的实现">事务性内存的实现</h3>

<p>​	TM 可以分成 STM 和 HTM 两大类。</p>

<p>​	STM（s 指 Software）通过软件来实现 TM，采用读/写屏障来实现 TM 中共享内存的读和写。具体做法是在代码中加入 stmStart() 和 stmCommit() 表示事务的开始和提交，stmRead() 和 stmWrite() 函数代替对内存的直接访问。这两个函数的内部实现也是通过加锁完成的，相比直接用锁优势仅仅在于采取了数据版本化所以事务回退时回复更加方便。为此付出的代价也是巨大的，比传统方法会有40%~50%的额外成本，如果需要保持隔离性会更高。</p>

<p>​	HTM（h 指 Hardware）利用了 cache 的层次结构，每个 cache line 都维护了两个 bit 用来表示是否被当前事务读/写。对于 eager versioning，在第一次写时会将地址写入 undo log 以备回退时回复数据。对于 lazy versioning，写入时修改缓存中对应地址的 W bit，如果事务回退，通过将所有 W bit 为 1 的 cache line 舍弃来缓存清空。</p>

<h2 id="总结">总结</h2>

<p>​	事务性内存作为锁机制的一个替代品，能够有效简化并行程序的编写。但是付出的代价就是硬件方面的改变和性能的下降，在实际中仍然需要对这些方面进行折中。</p>]]></content><author><name>unicornt</name><email>unicorntwin@outlook.com</email></author><category term="OS-report" /><summary type="html"><![CDATA[事务性内存]]></summary></entry><entry><title type="html">OS-report06</title><link href="https://blog.unicornt.cn/2021/01/14/OS-Report06.html" rel="alternate" type="text/html" title="OS-report06" /><published>2021-01-14T00:00:00+08:00</published><updated>2021-01-14T00:00:00+08:00</updated><id>https://blog.unicornt.cn/2021/01/14/OS-Report06</id><content type="html" xml:base="https://blog.unicornt.cn/2021/01/14/OS-Report06.html"><![CDATA[<p>文件系统</p>

<!--more-->

<p>​	新文件系统的目标是通过更加多变的分配原则来获得更好的访问局部性以提升磁盘的吞吐率，并适配更多的外围设备和处理器特征。</p>

<h2 id="旧文件系统">旧文件系统</h2>

<p>​	文件系统中每个磁盘被分成一个或多个分区，每个都包含一个文件系统，一个文件系统不会跨越多个分区。文件系统被它的 superblock 描述，包括基本常量，文件的最大数目，指向 freelist 的指针，空块的链表。文件系统内是文件，一些文件被当作目录，包含了指向其他文件（其中一些是目录）的指针。每个文件有一个 inode 和它相连。inode 包含文件的所有者，上次修改，上次访问的时间戳，文件包含数据块的索引数组。
​	这样设计的问题在于将 inode 用 data 隔开，导致寻找文件需要查找很多非连续的块。
​	Berkeley 做的第一件事就是增加文件系统的可靠性和吞吐率。加强可靠性的方式是进行对关键系统信息的修改使文件在崩溃后能够进行复原或完成。性能的增加通过将基本块大小从 512 变成 1024。但是即使做了这样的修改，也只使用了硬盘的 4% 的带宽。主要问题是随着文件的创建和删除，freelist 会变得完全随机，导致大文件的数据块在硬盘中随机分布，</p>

<h2 id="新文件系统">新文件系统</h2>

<p>​	与旧文件系统相同的是，每个磁盘包括一个或多个文件系统。一个文件系统由一个位于文件系统的磁盘分区开头的超级块来描述，因为超级块包含了关键文件，所以为超级块创建了备份以防止破坏性损失。
​	为了保证能够创建 $2^{32}$ 大小的文件，最小文件块为 4096 bytes。文件系统的块大小可以是 4096 的任意 2 的倍数，块大小会被记录在超级块中。
​	将硬盘分区分成多个名叫柱面组。一个柱面组包含了一个或多个磁盘上连续的柱面。每个柱面组包含有超级块的多余备份，inode 的空间，记录可用块的 bitmap。bitmap 用来取代传统的 freelist 以记录可用的块，好处在于不会因为文件系统使用时间的增长而导致freelist 变得随机从而丧失连续性。每个柱面组包含了固定数量的 inode。
​	如果将超级块的多余备份全部放在顶盘。一次简单的硬件错误就可能摧毁所有柱面组的记录信息。因此，不同柱面组的记录信息的偏移量和相邻柱面组有一个轨道的差别。
​	大数据块的问题在于 unix 系统由很多小文件组成（实际上虽然现在大文件很多，但是小文件的数量还是非常可观的）。为了防止浪费，新文件系统支持对一个文件系统块的分割（分割成碎片）。碎片大小在文件系统创建的时候设定，每个系统块可以被分成 2，4，8 个碎片。如果一个程序需要 11 个碎片，而一个块分成 4 个碎片，如果没有一个块有 3 个空闲的碎片，就将一个新的块分成 4 个碎片。
​	当程序进行 write 系统调用的时候，操作系统会检查文件大小是否增加，会有以下三种情况：</p>

<ol>
  <li>
    <p>当前块或者碎片有足够的空间。可以直接分配。</p>
  </li>
  <li>
    <p>文件没有碎片（而且块中没有足够的空间）。如果添加的文件大小大于一个块，就分配一个块直到需要分配的空间小于一个块，分配适当的碎片数或者一个块。</p>
  </li>
  <li>
    <p>文件有一个或者多个碎片。如果新数据和碎片中的数据加起来大于一个块，就新分配一个块，碎片中的数据会被复制到新块的开头，然后就是（2）情况。</p>
  </li>
</ol>

<p>​    4096/1024 文件系统中的空间浪费被证实和1024-旧文件系统相近, 4096/512 和 512-UNIX文件系统差不多，新文件系统使用更少的空间来定位大文件，相同的空间来定位小文件。
​    为了保证分配策略的高效性，文件系统不能被完全分配，每个文件系统会有一个常数，当文件系统中可分配的空块小于这个数值的时候，只有管理员能够继续分配。如果文件系统的空间被完全分配，由于无法将文件缓存（利用局部性），吞吐率会降低到原来的1/2.</p>

<h2 id="参数化">参数化</h2>

<p>​	旧文件系统忽略了底层硬件的参数，新文件系统进行参数化以适应各种磁盘的特征。
​	对于大规模存储设备比如磁盘，文件系统会将相同文件的块分配在同一个柱面中。最优情况下，这些新块需要适合（磁盘）旋转地放置（以下称旋转最优），“适合旋转的放置”可以是相邻的块，或者根据系统参数有旋转延迟的位置
​	每个磁盘的物理参数包括每个磁道上的块数目，磁盘的旋转速率，用于计算跳过一个块所需的时间。处理器的参数包括触发一个中断并调度一个磁盘转移的时间。当分配一个新块给文件的时候，分配策略会计算跳过块的个数。为了加速运算，超级块中维护了rational layout table。如果文件系统的参数设计成2ms 而处理器需要 4ms 来调度一个磁盘读写，吞吐量会降低一半。</p>

<h2 id="分配原则">分配原则</h2>

<p>​	文件系统的分配原则可以分成两个方面，一方面是全局原则，使用文件系统的简要信息来选择 inode 和数据块的放置位置，以及旋转最优块，寻找一个新柱面组的时机。</p>

<p>​	分配原则需要引用的文件数据不能太少也不能太多，需要进行平衡。分配策略有两方面的考虑：
​	a. inode 文件的使用。分配原则尝试将统一目录下的文件放在同一柱面组。新目录会被分配在有超过平均数值的空 inode 数的柱面组下，这个策略保证了inode 的簇聚性在大部分情况下能够成立。
​	b. datablocks。将相同文件的数据块放在同一个柱面组中。这样的问题在于大文件会很快用尽柱面组中的空间，因此需要进行分段，找到一个空块数大于平均的柱面组放置。
​	全局原则会调用局部原则以请求特别的数据块。局部分配策略会在请求块是空的时候进行分配，否则会分配一个旋转最优的空块。如果全局分配原则有足够的信息，总能找到适合大小的空块，这样分配策略就只剩下信息记录的工作。但是，维护完整的信息耗费巨大，所以全局分配策略使用启发式策略，仅仅记录部分信息。如果一个被请求的块不可用，局部策略会使用四级分配策略：</p>

<ol>
  <li>
    <p>使用旋转最优块</p>
  </li>
  <li>
    <p>如果当前柱面没有可用块，使用同柱面组的块。</p>
  </li>
  <li>
    <p>如果柱面组全都满了，二次哈希柱面组号来找到其他的柱面组以寻找空块。</p>
  </li>
  <li>
    <p>如果哈希失败，对所有的柱面组进行遍历</p>

    <p>使用二次哈希因为这种方法在几乎满的哈希表中寻找未使用的槽速度非常快。</p>
  </li>
</ol>

<h2 id="功能增强">功能增强</h2>

<h3 id="长文件名">长文件名</h3>

<p>​	文件名可以是任意长度，只有读取目录的程序才会受到影响。目录在一个 512bytes 的单元 chunk 中分配。之所以这个大小是因每个分配都可以在单次操作中传输到硬盘。chunk 被分成可变长的目录条目。每个条目都包括找到 inode 的必要信息，目录条目的前三个字段是 inode 号，字段长度，文件名长度。</p>

<h3 id="文件锁">文件锁</h3>

<p>​	旧文件系统采用另外的锁文件来来实现同步。这种方式有三个缺点：1.进程会消耗CPU时间来反复尝试创建锁。2.系统崩溃后必须手动清除锁。3.管理员模式下的进程总是被允许创建文件，所以需要采用不同的机制。新文件系统提供了共享锁和排他锁，这些锁只能被咨询，即使一个进程已经拥有了锁，其他进程也可以访问这些锁文件。</p>

<h3 id="符号链接">符号链接</h3>

<p>​	传统的链接无法跨越文件系统，符号连接可以解决这个问题。</p>

<h3 id="重命名">重命名</h3>

<p>​	传统的重命名需要调用三个系统调用，如果中途系统崩溃，目标文件会只剩下暂时的名字。新的重命名操作会保证目标文件的名字的存在。</p>

<h2 id="总结">总结</h2>

<p>​	新文件系统优化的关键在于：在文件写入的时候就充分考虑了文件访问的局部性原理，加速了文件读取；采用参数化适配不同的硬件。</p>

<p>​	为了体现局部性的同时减少内碎片，文件系统创造性的使用了碎片-块-柱面-柱面组-分区这样的层次结构，在保证局部性能够比较好体现的同时，也让文件系统碎片较少出现。</p>

<p>​	局部性主要体现在柱面和柱面组的层面，而碎片和块主要使应对内碎片的产生。在这种层次结构下，文件系统采用了局部-全局两种分配策略，既能够把控全局，又能够精细管理每个柱面。同时，二次哈希算法的使用保证了分配的高效性。</p>

<p>​	参数化的主要方式是利用 cpu 和磁盘的信息，得到最优的“下一个”分区位置，让文件系统局部性能够在不同的设备上更好的体现。</p>]]></content><author><name>unicornt</name><email>unicorntwin@outlook.com</email></author><category term="OS-report" /><summary type="html"><![CDATA[文件系统]]></summary></entry></feed>