deploy: c587c4a

_sources/chapter5/4scheduling.rst.txt

@@ -76,17 +76,17 @@
 性能指标
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-我们还需给出性能指标，用于衡量，比较和评价不同的调度策略。对于批处理系统中的一般应用而言，可以只有一个性能指标：周转时间（turn around time），即进程完成时间与进程到达时间的差值：
+我们还需给出性能指标，用于衡量，比较和评价不同的调度策略。对于批处理系统中的一般应用而言，可以只有一个性能指标：周转时间（turn around），即进程完成时间（completion）与进程到达时间（arrival）的差值：
 
 .. math::
 
-    T_{周转时间} = T_{完成时间} − T_{到达时间}
+    T_{\text{turn around}} = T_{\text{completion}} − T_{\text{arrival}}
 
-由于前提条件1 明确指出所有进程在同一时间到达，那么 :math:`T_{到达时间} = 0` ，因此 :math:`T_{周转时间} = T_{完成时间}` 。除了总的周转时间，我们还需要关注平均周转时间这样的统计值：
+由于前提条件1 明确指出所有进程在同一时间到达，那么 :math:`T_{\text{arrival}} = 0` ，因此 :math:`T_{\text{turn around}} = T_{\text{completion}}` 。除了总的周转时间，我们还需要关注平均周转时间（average turnaround）这样的统计值：
 
 .. math::
 
-    T_{平均周转时间} =  T_{周转时间} / 就绪进程个数
+    T_{\text{average turnaround}} =  T_{\text{turn around}} / \text{number of ready processes}
 
 对于单个进程而言，平均周转时间是一个更值得关注的性能指标。
 
@@ -189,13 +189,13 @@
 
 .. math::
 
-    T_{响应时间} = T_{首次执行} - T_{到达时间}
+    T_{\text{response time}} = T_{\text{first execution}} - T_{\text{arrival}}
 
-而对应的平均响应时间是：
+而对应的平均响应时间（average response time）是：
 
 .. math::
 
-   T_{平均响应时间} = T_{响应时间} / 就绪进程个数
+   T_{\text{average response time}} = T_{\text{response time}} / \text{number of ready processes}
 
 例如，操作系统采用SJF调度策略（不支持抢占进程），有两个进程，PA在时间0到达，执行时间为100， PB在时间20到达，执行时间为20，那么PA的响应时间为0，PB为80，平均响应时间为 40 。
 

_sources/chapter8/4condition-variable.rst.txt

@@ -225,9 +225,9 @@
 
 由于互斥锁的存在， ``signal`` 操作也不只是简单的唤醒操作。当线程 :math:`T_1` 在执行过程（位于管程过程中）中发现某条件满足准备唤醒线程 :math:`T_2` 的时候，如果直接让线程 :math:`T_2` 继续执行（也位于管程过程中），就会违背管程过程的互斥访问要求。因此，问题的关键是，在 :math:`T_1` 唤醒 :math:`T_2` 的时候， :math:`T_1` 如何处理它正持有的锁。具体来说，根据相关线程的优先级顺序，唤醒操作有这几种语义：
 
-- Hoare 语义：优先级 :math:`T_2>T_1>其他线程` 。也就是说，当 :math:`T_1` 发现条件满足之后，立即通过 ``signal`` 唤醒 :math:`T_2` 并 **将锁转交** 给 :math:`T_2` ，这样 :math:`T_2` 就能立即继续执行，而 :math:`T_1` 则暂停执行并进入一个 *紧急等待队列* 。当 :math:`T_2` 退出管程过程后会将锁交回给紧急等待队列中的 :math:`T_1` ，从而 :math:`T_1` 可以继续执行。
-- Hansen 语义：优先级 :math:`T_1>T_2>其他线程` 。即 :math:`T_1` 发现条件满足之后，先继续执行，直到退出管程之前再使用 ``signal`` 唤醒并 **将锁转交** 给 :math:`T_2` ，于是 :math:`T_2` 可以继续执行。注意在 Hansen 语义下， ``signal`` 必须位于管程过程末尾。
-- Mesa 语义：优先级 :math:`T_1>T_2=其他线程` 。即 :math:`T_1` 发现条件满足之后，就可以使用 ``signal`` 唤醒 :math:`T_2` ，但是并 **不会将锁转交** 给 :math:`T_2` 。这意味着在 :math:`T_1` 退出管程过程释放锁之后， :math:`T_2` 还需要和其他线程竞争，直到抢到锁之后才能继续执行。
+- Hoare 语义：优先级 :math:`T_2>T_1>\text{other processes}` 。也就是说，当 :math:`T_1` 发现条件满足之后，立即通过 ``signal`` 唤醒 :math:`T_2` 并 **将锁转交** 给 :math:`T_2` ，这样 :math:`T_2` 就能立即继续执行，而 :math:`T_1` 则暂停执行并进入一个 *紧急等待队列* 。当 :math:`T_2` 退出管程过程后会将锁交回给紧急等待队列中的 :math:`T_1` ，从而 :math:`T_1` 可以继续执行。
+- Hansen 语义：优先级 :math:`T_1>T_2>\text{other processes}` 。即 :math:`T_1` 发现条件满足之后，先继续执行，直到退出管程之前再使用 ``signal`` 唤醒并 **将锁转交** 给 :math:`T_2` ，于是 :math:`T_2` 可以继续执行。注意在 Hansen 语义下， ``signal`` 必须位于管程过程末尾。
+- Mesa 语义：优先级 :math:`T_1>T_2=\text{other processes}` 。即 :math:`T_1` 发现条件满足之后，就可以使用 ``signal`` 唤醒 :math:`T_2` ，但是并 **不会将锁转交** 给 :math:`T_2` 。这意味着在 :math:`T_1` 退出管程过程释放锁之后， :math:`T_2` 还需要和其他线程竞争，直到抢到锁之后才能继续执行。
 
 这些优先级顺序如下图所示：
 

chapter5/4scheduling.html

@@ -439,15 +439,15 @@ <h3>约束条件<a class="headerlink" href="#id7" title="永久链接至标题">
 </div>
 <div class="section" id="id8">
 <h3>性能指标<a class="headerlink" href="#id8" title="永久链接至标题">#</a></h3>
-<p>我们还需给出性能指标，用于衡量，比较和评价不同的调度策略。对于批处理系统中的一般应用而言，可以只有一个性能指标：周转时间（turn around time），即进程完成时间与进程到达时间的差值：</p>
+<p>我们还需给出性能指标，用于衡量，比较和评价不同的调度策略。对于批处理系统中的一般应用而言，可以只有一个性能指标：周转时间（turn around），即进程完成时间（completion）与进程到达时间（arrival）的差值：</p>
 <div class="math-wrapper docutils container">
 <div class="math notranslate nohighlight">
-\[T_{周转时间} = T_{完成时间} − T_{到达时间}\]</div>
+\[T_{\text{turn around}} = T_{\text{completion}} − T_{\text{arrival}}\]</div>
 </div>
-<p>由于前提条件1 明确指出所有进程在同一时间到达，那么 <span class="math notranslate nohighlight">\(T_{到达时间} = 0\)</span> ，因此 <span class="math notranslate nohighlight">\(T_{周转时间} = T_{完成时间}\)</span> 。除了总的周转时间，我们还需要关注平均周转时间这样的统计值：</p>
+<p>由于前提条件1 明确指出所有进程在同一时间到达，那么 <span class="math notranslate nohighlight">\(T_{\text{arrival}} = 0\)</span> ，因此 <span class="math notranslate nohighlight">\(T_{\text{turn around}} = T_{\text{completion}}\)</span> 。除了总的周转时间，我们还需要关注平均周转时间（average turnaround）这样的统计值：</p>
 <div class="math-wrapper docutils container">
 <div class="math notranslate nohighlight">
-\[T_{平均周转时间} =  T_{周转时间} / 就绪进程个数\]</div>
+\[T_{\text{average turnaround}} =  T_{\text{turn around}} / \text{number of ready processes}\]</div>
 </div>
 <p>对于单个进程而言，平均周转时间是一个更值得关注的性能指标。</p>
 </div>
@@ -514,12 +514,12 @@ <h3>性能指标<a class="headerlink" href="#id13" title="永久链接至标题"
 <p>操作系统支持任务/进程被抢占的一个重要目标是提高用户的交互性体验和减少I/O响应时间。用户希望计算机系统能及时响应他发出的I/O请求（如键盘、鼠标等），但平均周转时间这个性能指标不足以反映人机交互或I/O响应的性能。所以，我们需要定义新的性能指标 – 响应时间（response time）：</p>
 <div class="math-wrapper docutils container">
 <div class="math notranslate nohighlight">
-\[T_{响应时间} = T_{首次执行} - T_{到达时间}\]</div>
+\[T_{\text{response time}} = T_{\text{first execution}} - T_{\text{arrival}}\]</div>
 </div>
-<p>而对应的平均响应时间是：</p>
+<p>而对应的平均响应时间（average response time）是：</p>
 <div class="math-wrapper docutils container">
 <div class="math notranslate nohighlight">
-\[T_{平均响应时间} = T_{响应时间} / 就绪进程个数\]</div>
+\[T_{\text{average response time}} = T_{\text{response time}} / \text{number of ready processes}\]</div>
 </div>
 <p>例如，操作系统采用SJF调度策略（不支持抢占进程），有两个进程，PA在时间0到达，执行时间为100， PB在时间20到达，执行时间为20，那么PA的响应时间为0，PB为80，平均响应时间为 40 。</p>
 </div>

chapter8/4condition-variable.html

@@ -519,9 +519,9 @@ <h2>管程与条件变量<a class="headerlink" href="#id4" title="永久链接
 </ul>
 <p>由于互斥锁的存在， <code class="docutils literal notranslate"><span class="pre">signal</span></code> 操作也不只是简单的唤醒操作。当线程 <span class="math notranslate nohighlight">\(T_1\)</span> 在执行过程（位于管程过程中）中发现某条件满足准备唤醒线程 <span class="math notranslate nohighlight">\(T_2\)</span> 的时候，如果直接让线程 <span class="math notranslate nohighlight">\(T_2\)</span> 继续执行（也位于管程过程中），就会违背管程过程的互斥访问要求。因此，问题的关键是，在 <span class="math notranslate nohighlight">\(T_1\)</span> 唤醒 <span class="math notranslate nohighlight">\(T_2\)</span> 的时候， <span class="math notranslate nohighlight">\(T_1\)</span> 如何处理它正持有的锁。具体来说，根据相关线程的优先级顺序，唤醒操作有这几种语义：</p>
 <ul class="simple">
-<li><p>Hoare 语义：优先级 <span class="math notranslate nohighlight">\(T_2&gt;T_1&gt;其他线程\)</span> 。也就是说，当 <span class="math notranslate nohighlight">\(T_1\)</span> 发现条件满足之后，立即通过 <code class="docutils literal notranslate"><span class="pre">signal</span></code> 唤醒 <span class="math notranslate nohighlight">\(T_2\)</span> 并 <strong>将锁转交</strong> 给 <span class="math notranslate nohighlight">\(T_2\)</span> ，这样 <span class="math notranslate nohighlight">\(T_2\)</span> 就能立即继续执行，而 <span class="math notranslate nohighlight">\(T_1\)</span> 则暂停执行并进入一个 <em>紧急等待队列</em> 。当 <span class="math notranslate nohighlight">\(T_2\)</span> 退出管程过程后会将锁交回给紧急等待队列中的 <span class="math notranslate nohighlight">\(T_1\)</span> ，从而 <span class="math notranslate nohighlight">\(T_1\)</span> 可以继续执行。</p></li>
-<li><p>Hansen 语义：优先级 <span class="math notranslate nohighlight">\(T_1&gt;T_2&gt;其他线程\)</span> 。即 <span class="math notranslate nohighlight">\(T_1\)</span> 发现条件满足之后，先继续执行，直到退出管程之前再使用 <code class="docutils literal notranslate"><span class="pre">signal</span></code> 唤醒并 <strong>将锁转交</strong> 给 <span class="math notranslate nohighlight">\(T_2\)</span> ，于是 <span class="math notranslate nohighlight">\(T_2\)</span> 可以继续执行。注意在 Hansen 语义下， <code class="docutils literal notranslate"><span class="pre">signal</span></code> 必须位于管程过程末尾。</p></li>
-<li><p>Mesa 语义：优先级 <span class="math notranslate nohighlight">\(T_1&gt;T_2=其他线程\)</span> 。即 <span class="math notranslate nohighlight">\(T_1\)</span> 发现条件满足之后，就可以使用 <code class="docutils literal notranslate"><span class="pre">signal</span></code> 唤醒 <span class="math notranslate nohighlight">\(T_2\)</span> ，但是并 <strong>不会将锁转交</strong> 给 <span class="math notranslate nohighlight">\(T_2\)</span> 。这意味着在 <span class="math notranslate nohighlight">\(T_1\)</span> 退出管程过程释放锁之后， <span class="math notranslate nohighlight">\(T_2\)</span> 还需要和其他线程竞争，直到抢到锁之后才能继续执行。</p></li>
+<li><p>Hoare 语义：优先级 <span class="math notranslate nohighlight">\(T_2&gt;T_1&gt;\text{other processes}\)</span> 。也就是说，当 <span class="math notranslate nohighlight">\(T_1\)</span> 发现条件满足之后，立即通过 <code class="docutils literal notranslate"><span class="pre">signal</span></code> 唤醒 <span class="math notranslate nohighlight">\(T_2\)</span> 并 <strong>将锁转交</strong> 给 <span class="math notranslate nohighlight">\(T_2\)</span> ，这样 <span class="math notranslate nohighlight">\(T_2\)</span> 就能立即继续执行，而 <span class="math notranslate nohighlight">\(T_1\)</span> 则暂停执行并进入一个 <em>紧急等待队列</em> 。当 <span class="math notranslate nohighlight">\(T_2\)</span> 退出管程过程后会将锁交回给紧急等待队列中的 <span class="math notranslate nohighlight">\(T_1\)</span> ，从而 <span class="math notranslate nohighlight">\(T_1\)</span> 可以继续执行。</p></li>
+<li><p>Hansen 语义：优先级 <span class="math notranslate nohighlight">\(T_1&gt;T_2&gt;\text{other processes}\)</span> 。即 <span class="math notranslate nohighlight">\(T_1\)</span> 发现条件满足之后，先继续执行，直到退出管程之前再使用 <code class="docutils literal notranslate"><span class="pre">signal</span></code> 唤醒并 <strong>将锁转交</strong> 给 <span class="math notranslate nohighlight">\(T_2\)</span> ，于是 <span class="math notranslate nohighlight">\(T_2\)</span> 可以继续执行。注意在 Hansen 语义下， <code class="docutils literal notranslate"><span class="pre">signal</span></code> 必须位于管程过程末尾。</p></li>
+<li><p>Mesa 语义：优先级 <span class="math notranslate nohighlight">\(T_1&gt;T_2=\text{other processes}\)</span> 。即 <span class="math notranslate nohighlight">\(T_1\)</span> 发现条件满足之后，就可以使用 <code class="docutils literal notranslate"><span class="pre">signal</span></code> 唤醒 <span class="math notranslate nohighlight">\(T_2\)</span> ，但是并 <strong>不会将锁转交</strong> 给 <span class="math notranslate nohighlight">\(T_2\)</span> 。这意味着在 <span class="math notranslate nohighlight">\(T_1\)</span> 退出管程过程释放锁之后， <span class="math notranslate nohighlight">\(T_2\)</span> 还需要和其他线程竞争，直到抢到锁之后才能继续执行。</p></li>
 </ul>
 <p>这些优先级顺序如下图所示：</p>
 <img alt="../_images/condvar-priority.png" class="align-center" src="../_images/condvar-priority.png" />