该主题尚不存在

本页面只读。您可以查看源文件，但不能更改它。如果您觉得这是系统错误，请联系管理员。
====== 第七章：计算机性能评价 ======

  * [[#7.1 计算机性能指标|7.1 计算机性能指标]]
  * [[#7.2 CPU性能分析|7.2 CPU性能分析]]
  * [[#7.3 系统性能评测|7.3 系统性能评测]]
  * [[#7.4 性能优化技术|7.4 性能优化技术]]
  * [[#7.5 功耗与能效|7.5 功耗与能效]]
  * [[#7.6 练习题|7.6 练习题]]

----

===== 章节概述 =====

本章介绍计算机系统性能的评测方法和优化技术，包括CPU性能指标、系统性能评测方法、性能优化策略以及功耗与能效分析。通过本章学习，理解计算机性能的评价标准，掌握性能分析和优化的基本方法。

**学习目标**：
  * 理解计算机性能的主要评价指标
  * 掌握CPU性能的计算方法
  * 理解Amdahl定律及其应用
  * 了解常用的基准测试程序
  * 掌握常见的性能优化技术
  * 理解功耗与性能的关系

**本章重点**：
  - CPU性能指标及其计算方法
  - Amdahl定律及其应用
  - 基准测试程序的选择和使用
  - 性能优化技术

**本章难点**：
  - CPU时间计算和性能比较
  - Amdahl定律的理解和应用
  - 系统瓶颈分析
  - 功耗墙和暗硅问题

----

===== 7.1 计算机性能指标 =====

计算机性能评价是计算机系统设计、选型和优化的重要基础。不同的应用场景对性能的要求不同，因此需要多个指标来全面评价计算机性能。

====== 7.1.1 响应时间与吞吐量 ======

**响应时间（Response Time）**：
  * 从提交请求到获得响应的时间间隔
  * 又称执行时间、等待时间、延迟
  * 衡量单个任务的完成速度
  * 越短越好，是用户直接感知的性能指标

**吞吐量（Throughput）**：
  * 单位时间内完成的工作量
  * 如：每秒处理的事务数（TPS）、每秒完成的作业数
  * 衡量系统整体处理能力
  * 越大越好，是系统级性能指标

<code>
响应时间与吞吐量的关系：

单机场景：
  - 减少响应时间通常会提高吞吐量
  - 如：程序优化后执行更快，单位时间完成的任务更多
  
多任务场景：
  - 可能存在权衡
  - 增加处理器数量可能提高吞吐量，但单个任务的响应时间可能不变
  - 例如：8核处理器可以同时处理8个任务，吞吐量提高8倍，
    但每个任务的响应时间与单核相同

┌─────────────────────────────────────────────────────┐
│                    响应时间 vs 吞吐量                │
├─────────────────────────────────────────────────────┤
│                                                     │
│  响应时间 ↓                                         │
│       │                                             │
│       │    ╱ 优化单机性能                           │
│       │   ╱  （响应时间和吞吐量同时改善）            │
│       │  ╱                                          │
│       │ ╱                                           │
│       │╱  增加处理器数量                             │
│       └──────────────→ 吞吐量 ↑                      │
│          （吞吐量提高，响应时间不变）                │
│                                                     │
└─────────────────────────────────────────────────────┘
</code>

**实际应用**：
  * 交互式应用（如网页浏览）更关注响应时间
  * 服务器应用（如Web服务器）更关注吞吐量
  * 实时系统需要同时满足响应时间和吞吐量要求

====== 7.1.2 CPU性能指标 ======

**CPU执行时间**：CPU执行程序所花费的时间，不包括I/O等待时间

**时钟周期（Clock Cycle）**：计算机主时钟的周期时间
  * 时钟周期 = 1 / 时钟频率
  * 如：1GHz时钟频率对应1ns时钟周期

**时钟频率（Clock Rate）**：每秒的时钟周期数
  * 单位：Hz、MHz、GHz
  * 如：3GHz表示每秒30亿个时钟周期

**CPI（Cycles Per Instruction）**：每条指令的平均时钟周期数
  * 反映指令执行的效率
  * 受指令类型、流水线效率、Cache命中率等因素影响

**MIPS（Million Instructions Per Second）**：每秒执行的百万条指令数
  * MIPS = 指令数 / (执行时间 × 10^6)
  * 或：MIPS = 时钟频率 / (CPI × 10^6)

**MFLOPS（Million Floating-point Operations Per Second）**：每秒百万次浮点运算
  * 用于评价科学计算性能
  * GFLOPS = 10^9次浮点运算/秒
  * TFLOPS = 10^12次浮点运算/秒
  * PFLOPS = 10^15次浮点运算/秒

<code>
CPU性能指标关系图：

┌─────────────────────────────────────────────────────────────┐
│                      CPU性能指标                             │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   时钟频率（GHz）                                            │
│        │                                                    │
│        ▼                                                    │
│   时钟周期（ns） = 1 / 时钟频率                              │
│        │                                                    │
│        ▼                                                    │
│   CPU时间 = 指令数 × CPI × 时钟周期                         │
│                      ▲                                      │
│                      │                                      │
│              指令类型比例                                   │
│              流水线效率                                     │
│              Cache命中率                                    │
│                                                             │
└─────────────────────────────────────────────────────────────┘
</code>

====== 7.1.3 性能计算公式 ======

**基本公式**：

<code>
CPU执行时间 = 指令数 × CPI × 时钟周期
            = 指令数 × CPI / 时钟频率

示例：
程序包含1000条指令
CPI = 2
时钟频率 = 2GHz

CPU执行时间 = 1000 × 2 / (2×10^9) 
            = 1000 纳秒
            = 1 微秒
</code>

**MIPS计算**：
<code>
MIPS = 指令数 / (执行时间 × 10^6)
     = 时钟频率 / (CPI × 10^6)

注意：MIPS受指令集影响，不同机器的指令复杂度不同，
      因此MIPS不能直接比较不同架构的性能
</code>

**性能比较**：
<code>
性能比 = 性能_A / 性能_B = 执行时间_B / 执行时间_A

如果性能比 = n，则说"A的速度是B的n倍"
或"A比B快n-1倍"

注意："快n倍"和"是n倍"的区别
- "A比B快2倍" 表示 A的速度 = B的速度 × 3
- "A的速度是B的2倍" 表示 A的速度 = B的速度 × 2

示例：
程序在A机器上运行10秒，在B机器上运行15秒
性能比 = 15 / 10 = 1.5
A的速度是B的1.5倍，或A比B快50%
</code>

**综合性能计算示例**：

<code>
假设两台机器的对比：

机器A：时钟频率2GHz，CPI=2.0
机器B：时钟频率1.5GHz，CPI=1.5

对于同样的程序（指令数相同）：

CPU时间_A = 指令数 × 2.0 / 2×10^9 = 指令数 × 10^-9
CPU时间_B = 指令数 × 1.5 / 1.5×10^9 = 指令数 × 10^-9

结论：两台机器执行时间相同！
说明：不能只看时钟频率，CPI也很重要
</code>

----

===== 7.2 CPU性能分析 =====

====== 7.2.1 影响CPU性能的因素 ======

CPU性能由三个关键因素决定：指令数、CPI、时钟频率。

**指令数**：
  * 受指令集架构（ISA）影响
  * 受编译器优化影响
  * 受程序算法影响
  * 不同ISA的指令数差异很大（CISC vs RISC）

**CPI（每条指令的时钟周期数）**：
  * 受处理器微架构影响
  * 流水线深度和效率
  * 分支预测命中率
  * Cache命中率
  * 指令级并行性（ILP）

**时钟频率**：
  * 受制造工艺影响（纳米制程）
  * 受功耗限制（功耗墙）
  * 受散热条件限制
  * 受关键路径延迟限制

<code>
影响CPU性能的三要素：

        ┌─────────────────────────────────────┐
        │            程序执行时间            │
        │   = 指令数 × CPI × 时钟周期       │
        └─────────────────────────────────────┘
                      ▲
         ┌───────────┼───────────┐
         │           │           │
         ▼           ▼           ▼
    ┌─────────┐ ┌─────────┐ ┌─────────┐
    │ 指令数  │ │   CPI   │ │时钟频率 │
    │         │ │         │ │         │
    │•算法    │ │•流水线 │ │•工艺   │
    │•编译器  │ │•分支预测│ │•功耗   │
    │•ISA     │ │•Cache  │ │•散热   │
    └─────────┘ └─────────┘ └─────────┘
</code>

**性能优化方向**：
  * 减少指令数：优化算法、编译器优化
  * 降低CPI：提高流水线效率、改善Cache性能、优化分支预测
  * 提高时钟频率：改进工艺、降低功耗

====== 7.2.2 Amdahl定律 ======

**Amdahl定律**：用于计算系统某部分改进后整体性能的提升。

<code>
加速比 = 1 / [(1 - 可改进比例) + 可改进比例/部件加速比]

变量说明：
- 可改进比例：原程序中可改进部分的执行时间比例
- 部件加速比：改进后该部分的加速倍数
- 加速比：整体程序的加速倍数

示例1：
某程序运行时间100秒，其中乘法运算占40秒。
如果将乘法运算速度提高4倍，总加速比是多少？

可改进比例 = 40/100 = 0.4
部件加速比 = 4

加速比 = 1 / [(1-0.4) + 0.4/4]
       = 1 / [0.6 + 0.1]
       = 1 / 0.7
       ≈ 1.43

改进后的执行时间 = 100 / 1.43 ≈ 70秒
</code>

**Amdahl定律的启示**：
  * 改进效果显著部分对整体性能影响大
  * 频繁使用的部分值得优化（80/20法则）
  * 优化有极限，不能无限加速
  * 即使某部分加速到无穷大，整体加速比上限为：1/(1-可改进比例)

<code>
加速比上限分析：

当部件加速比 → ∞ 时：
加速比_max = 1 / (1 - 可改进比例)

可改进比例    最大加速比
   0.1           1.11
   0.2           1.25
   0.5           2.00
   0.9          10.00
   0.95         20.00

结论：要想获得显著的性能提升，必须改进
      程序中占用时间较大的部分
</code>

**Amdahl定律应用示例**：

<code>
例2：多核扩展性分析
某程序中可并行部分占80%，串行部分占20%。
使用多少核才能获得10倍加速？

设使用n个核：
加速比 = 1 / [0.2 + 0.8/n] = 10

解方程：
0.2 + 0.8/n = 0.1
0.8/n = -0.1  （无解！）

结论：由于串行部分占20%，即使使用无限多核，
      最大加速比也只有 1/0.2 = 5倍
      永远无法达到10倍加速

例3：优化选择
方案A：优化占50%时间的部分，加速比2倍
方案B：优化占10%时间的部分，加速比10倍

方案A加速比 = 1 / [0.5 + 0.5/2] = 1.33
方案B加速比 = 1 / [0.9 + 0.1/10] = 1.10

结论：方案A效果更好，说明优化高频部分更重要
</code>

====== 7.2.3 指令类型与CPI ======

不同类型指令的CPI不同：

| 指令类型 | 典型CPI | 说明 |
|---------|--------|------|
| 整数运算 | 1 | 简单ALU操作，单周期完成 |
| 浮点运算 | 3-5 | 需要多周期完成（如乘法、除法） |
| 内存访问（Cache命中） | 1-2 | 数据在L1 Cache中 |
| 内存访问（Cache未命中） | 10-100+ | 需要访问L2/L3/内存 |
| 分支指令（预测正确） | 1 | 流水线正常执行 |
| 分支指令（预测错误） | 10-20 | 需要清空流水线 |

**加权平均CPI计算**：
<code>
CPI_平均 = Σ(CPI_i × 指令比例_i)

示例：
某程序中各类指令比例和CPI：
- ALU指令：50%，CPI=1
- 访存指令：30%，CPI=4（Cache命中率90%，未命中时CPI=100）
- 分支指令：20%，CPI=2

首先计算有效访存CPI：
CPI_访存 = 0.9×4 + 0.1×100 = 13.6

然后计算平均CPI：
CPI_平均 = 1×0.5 + 13.6×0.3 + 2×0.2
         = 0.5 + 4.08 + 0.4
         = 4.98

可见Cache未命中对性能影响很大！
</code>

----

===== 7.3 系统性能评测 =====

====== 7.3.1 基准测试程序 ======

**基准测试程序（Benchmark）**：用于评测计算机性能的标准程序集合，模拟实际工作负载。

**SPEC基准测试**（Standard Performance Evaluation Corp）：

**SPEC CPU**：测试处理器性能
  * SPECint：整数运算性能（如编译器、压缩、视频编码）
  * SPECfp：浮点运算性能（如科学计算、有限元分析）
  * 最新版本：SPEC CPU 2017

**SPEC Power**：测试功耗性能
  * 测量不同负载下的性能和功耗
  * 计算性能/功耗比

**SPEC JVM**：测试Java性能

<code>
SPEC CPU 2017测试套件包含：

整数测试（SPECint2017）：
- 600.perlbench：Perl解释器
- 602.gcc：C编译器
- 605.mcf：组合优化
- 620.omnetpp：离散事件仿真
- 623.xalancbmk：XML处理
- 625.x264：视频压缩
- 631.deepsjeng：人工智能（围棋）
- 641.leela：人工智能（围棋）
- 648.exchange2：编程语言解释器
- 657.xz：数据压缩

浮点测试（SPECfp2017）：
- 603.bwaves：流体动力学
- 607.cactuBSSN：物理学
- 619.lbm：流体动力学
- 621.wrf：天气预报
- 627.cam4：气候建模
- 628.pop2：海洋建模
- 638.imagick：图像处理
- 644.nab：分子动力学
- 649.fotonik3d：计算电磁学
- 654.roms：海洋建模
</code>

**其他基准测试**：

**TPC基准测试**（Transaction Processing Performance Council）：
  * TPC-C：在线事务处理（OLTP）
  * TPC-H：决策支持（数据仓库）
  * TPC-DS：大数据分析
  * 指标：tpmC（每分钟事务数）

**LINPACK**：
  * 解线性方程组
  * 测试浮点运算性能
  * 超级计算机排名基准（TOP500）

**Geekbench**：
  * 跨平台综合性能测试
  * 支持多种操作系统和架构

**Cinebench**：
  * 基于Cinema 4D的渲染测试
  * 测试CPU和GPU性能

====== 7.3.2 性能评测方法 ======

**真实程序测试**：
  * 使用实际应用程序测试
  * 结果最真实，最能反映实际性能
  * 但移植工作量大，测试时间长

**核心程序测试（Kernel）**：
  * 提取程序中最耗时的核心代码
  * 简化测试过程
  * 可能忽略系统其他方面（如I/O）

**合成测试程序**：
  * 模拟典型操作序列
  * 如：Whetstone（浮点测试）、Dhrystone（整数测试）
  * 便于比较，但可能与真实负载有差距
  * 现代已较少使用

**微基准测试**：
  * 测试特定组件性能
  * 如：内存带宽测试、Cache延迟测试、分支预测测试
  * 用于分析系统瓶颈

<code>
性能测试方法对比：

┌──────────────┬──────────┬──────────┬──────────┐
│   测试方法    │  真实性   │  可移植性 │  测试难度 │
├──────────────┼──────────┼──────────┼──────────┤
│ 真实程序      │   ★★★   │   ★☆☆   │   ★★★   │
│ 核心程序      │   ★★☆   │   ★★☆   │   ★★☆   │
│ 合成测试      │   ★☆☆   │   ★★★   │   ★☆☆   │
│ 微基准测试    │   ☆☆☆   │   ★★★   │   ★☆☆   │
└──────────────┴──────────┴──────────┴──────────┘
</code>

====== 7.3.3 性能测试注意事项 ======

**测试环境控制**：
  * 关闭无关程序和服务
  * 预热缓存（warm-up）
  * 多次测量取平均值
  * 报告测试配置和环境

**避免测量误差**：
  * 计时器精度（使用高精度计时器）
  * 操作系统开销
  * 随机干扰（如中断）
  * 计算统计置信区间

**结果解读**：
  * 单一指标往往不够全面
  * 结合实际应用场景
  * 考虑功耗、成本、可靠性等因素
  * 性能价格比（性价比）

<code>
测试报告示例：

测试配置：
- CPU：Intel Core i7-9700K @ 3.6GHz
- 内存：32GB DDR4-3200
- 操作系统：Ubuntu 20.04
- 编译器：GCC 9.3.0，优化级别-O2

测试结果（SPECint2017）：
- 600.perlbench：5.23
- 602.gcc：4.89
- ...
- 总体得分：5.12

测试注意事项：
- 运行3次取平均值
- 标准差 < 2%
- 关闭CPU动态频率调节
</code>

----

===== 7.4 性能优化技术 =====

====== 7.4.1 编译器优化 ======

编译器优化是提高程序性能的重要手段，无需修改源代码。

**优化级别**：
  * **-O0**：无优化，便于调试，编译速度最快
  * **-O1**：基本优化，平衡编译时间和性能
  * **-O2**：全面优化，推荐用于发布版本
  * **-O3**：激进优化，可能增加代码体积，某些情况下可能降低性能
  * **-Os**：优化代码大小，适合嵌入式系统
  * **-Ofast**：不遵守严格标准的高性能优化

**常见优化技术**：

<code>
1. 常量传播（Constant Propagation）
   原始代码：
   int x = 10;
   int y = x + 5;
   
   优化后：
   int x = 10;
   int y = 15;  // 直接替换为常量

2. 死代码消除（Dead Code Elimination）
   删除不会执行的代码
   
   原始代码：
   int x = 10;
   x = 20;
   return x;  // x=10被覆盖，是无用赋值
   
   优化后：
   int x = 20;
   return x;

3. 循环展开（Loop Unrolling）
   减少循环开销
   
   原始代码：
   for (int i = 0; i < 100; i++)
       sum += a[i];
   
   优化后（展开4倍）：
   for (int i = 0; i < 100; i += 4) {
       sum += a[i];
       sum += a[i+1];
       sum += a[i+2];
       sum += a[i+3];
   }

4. 函数内联（Function Inlining）
   减少函数调用开销
   
   原始代码：
   inline int add(int a, int b) { return a + b; }
   int x = add(3, 4);
   
   优化后：
   int x = 3 + 4;  // 直接展开

5. 指令调度（Instruction Scheduling）
   重排指令顺序，减少流水线停顿
</code>

====== 7.4.2 算法优化 ======

算法优化是最高效的优化方式，可以带来数量级的性能提升。

**时间复杂度优化**：
<code>
查找算法对比：

算法         时间复杂度      100万条记录查找
────────────────────────────────────────────
线性查找      O(n)           平均50万次比较
二分查找      O(log n)       最多20次比较
哈希查找      O(1)平均       1次查找
二叉搜索树    O(log n)平均   最多20次比较

排序算法对比：

算法         时间复杂度      100万条记录排序
────────────────────────────────────────────
冒泡排序      O(n²)          约1万亿次比较
快速排序      O(n log n)     约2000万次比较
归并排序      O(n log n)     约2000万次比较
计数排序      O(n+k)         约100万次操作
</code>

**空间换时间策略**：
  * 使用缓存存储中间结果（记忆化）
  * 预计算常用值（查表法）
  * 增加数据结构冗余以提高查询速度

<code>
空间换时间示例：

原始代码（计算阶乘）：
int factorial(int n) {
    if (n <= 1) return 1;
    return n * factorial(n-1);  // 每次都要重新计算
}

优化后（查表法）：
int fact_table[] = {1, 1, 2, 6, 24, 120, 720, ...};
int factorial(int n) {
    return fact_table[n];  // O(1)时间
}

斐波那契数列优化：
原始递归：O(2^n)
记忆化递归：O(n)
动态规划：O(n)
矩阵快速幂：O(log n)
</code>

====== 7.4.3 存储层次优化 ======

**Cache优化**：
  * 提高空间局部性：连续访问相邻数据
  * 提高时间局部性：重复使用数据
  * 避免Cache冲突：数据对齐，避免伪共享

<code>
Cache优化示例：

// 原始代码（按列访问，Cache不友好）
for (int j = 0; j < n; j++)
    for (int i = 0; i < n; i++)
        sum += a[i][j];

// 优化后（按行访问，Cache友好）
for (int i = 0; i < n; i++)
    for (int j = 0; j < n; j++)
        sum += a[i][j];

// 缓存分块（Cache Blocking/Tiling）
for (int ii = 0; ii < n; ii += BLOCK)
    for (int jj = 0; jj < n; jj += BLOCK)
        for (int i = ii; i < min(ii+BLOCK, n); i++)
            for (int j = jj; j < min(jj+BLOCK, n); j++)
                sum += a[i][j];
</code>

**预取技术**：
  * 硬件预取：处理器自动识别访问模式，提前加载数据
  * 软件预取：程序员插入预取指令（如_mm_prefetch）

<code>
软件预取示例：

for (int i = 0; i < n; i++) {
    _mm_prefetch(&a[i+16], _MM_HINT_T0);  // 预取数据到L1
    sum += a[i];
}
</code>

====== 7.4.4 并行与并发 ======

**指令级并行（ILP）**：
  * 流水线技术：将指令执行分为多个阶段，重叠执行
  * 超标量执行：每周期发射多条指令
  * 乱序执行（OoO）：动态调度指令，减少停顿
  * 分支预测：预测分支方向，减少流水线刷新

**线程级并行**：
  * 多线程编程
  * OpenMP：共享内存并行编程
  * POSIX线程（Pthreads）

**数据级并行**：
  * SIMD指令（单指令多数据）
  * x86：SSE（128位）、AVX（256位）、AVX-512（512位）
  * ARM：NEON

<code>
SIMD优化示例（使用AVX）：

// 普通循环
for (int i = 0; i < 1024; i++)
    c[i] = a[i] + b[i];

// AVX优化（一次处理8个float，256位）
#include <immintrin.h>
for (int i = 0; i < 1024; i += 8) {
    __m256 va = _mm256_load_ps(&a[i]);
    __m256 vb = _mm256_load_ps(&b[i]);
    __m256 vc = _mm256_add_ps(va, vb);
    _mm256_store_ps(&c[i], vc);
}

性能提升：理论上是8倍（实际约4-6倍，受内存带宽限制）
</code>

**GPU并行计算**：
  * 适合数据并行任务
  * CUDA、OpenCL编程
  * 数千个轻量级线程并行执行

====== 7.4.5 系统级优化 ======

**负载均衡**：
  * 任务分配到多个处理器
  * 避免某些处理器过载，某些空闲
  * 动态任务调度

**I/O优化**：
  * 异步I/O：不阻塞CPU等待I/O完成
  * 批量I/O：合并多个小I/O请求
  * 使用高速存储设备（SSD、NVMe）
  * I/O调度算法优化

**内存优化**：
  * 减少内存分配次数（使用内存池）
  * 避免内存碎片
  * 使用大页（Huge Pages）减少TLB未命中
  * 减少内存拷贝（零拷贝技术）

<code>
零拷贝技术示例：

传统文件发送：
磁盘 -> 内核缓冲区 -> 用户缓冲区 -> 内核套接字缓冲区 -> 网卡
（2次拷贝）

零拷贝（sendfile）：
磁盘 -> 内核缓冲区 -> 网卡
（0次用户态拷贝）

性能提升：减少CPU开销，提高吞吐量
</code>

----

===== 7.5 功耗与能效 =====

====== 7.5.1 功耗墙问题 ======

**功耗墙（Power Wall）**：随着晶体管密度增加，芯片功耗密度急剧上升，散热成为瓶颈。

**动态功耗公式**：
<code>
P_dynamic = C × V² × f

C：负载电容
V：工作电压
f：时钟频率

关键结论：
- 功耗与电压平方成正比
- 功耗与频率成正比
- 降低电压可显著降低功耗
</code>

**静态功耗**：
  * 晶体管漏电流导致
  * 随着制程缩小而增加
  * 即使芯片空闲也存在

**功耗墙的影响**：
  * 单核频率提升受限（无法散热）
  * 转向多核架构
  * 动态电压频率调节（DVFS）

<code>
功耗与性能关系：

功耗
  │
  │     ╱ 功耗墙
  │    ╱
  │   ╱
  │  ╱
  │ ╱
  │╱ 实际工作点
  └──────────────→ 性能
</code>

====== 7.5.2 能效指标 ======

**能效比**：性能与功耗的比值
  * 单位：Performance/Watt（性能每瓦特）
  * Green500排名使用此指标

**每指令能耗（Energy Per Instruction）**：
  * 反映处理器能效
  * 与CPI和功耗相关

**EEMBC能效基准**：
  * 嵌入式系统的能效测试
  * 测量工作负载下的能耗

<code>
能效优化策略：

1. 制程改进
   - 更小的纳米制程降低电容
   
2. 架构优化
   - 异构计算（大核+小核）
   - 根据负载选择合适的核心
   
3. 动态管理
   - DVFS：动态调整电压和频率
   - 空闲时降低频率或休眠
   
4. 软件优化
   - 减少指令数
   - 提高Cache命中率（减少访存能耗）
</code>

====== 7.5.3 暗硅问题 ======

**暗硅（Dark Silicon）**：由于功耗限制，芯片上部分晶体管不能同时工作，需要保持关闭状态。

**产生原因**：
  * 晶体管密度增长快于功耗效率提升
  * 芯片功耗预算有限
  * 散热能力受限

**应对策略**：
  * 专用加速器（根据负载启用不同模块）
  * 近阈值计算（降低工作电压）
  * 3D堆叠（提高集成度）

<code>
暗硅示意：

芯片面积：
┌─────────────────────────────┐
│  ████    暗硅（关闭）        │
│  ████  ┌─────┐  ████        │
│        │ 工作 │              │
│  ████  │ 核心 │  ████        │
│        └─────┘              │
│  ████    暗硅（关闭）  ████  │
└─────────────────────────────┘

只有约20-40%的晶体管可以同时工作
</code>

----

===== 7.6 练习题 =====

==== 一、选择题 ====

  1. 计算机性能的主要衡量指标是（  ）
     A. 存储容量    B. 响应时间    C. 字长    D. 指令条数

  2. 某CPU主频为2GHz，则其时钟周期为（  ）
     A. 2ns    B. 1ns    C. 0.5ns    D. 4ns

  3. CPI是指（  ）
     A. 每秒执行指令数    B. 每条指令的平均时钟周期数
     C. 指令执行时间      D. 处理器时钟频率

  4. 根据Amdahl定律，若某部件的加速比为无穷大，系统加速比的上限是（  ）
     A. 无穷大    B. 可改进比例的倒数    
     C. 1/(1-可改进比例)    D. 可改进比例

  5. 以下哪个基准测试主要用于测试处理器整数性能（  ）
     A. SPECfp    B. SPECint    C. LINPACK    D. TPC-C

  6. 动态功耗与哪个因素不成正比（  ）
     A. 负载电容    B. 工作电压    C. 时钟频率    D. 电压的平方

  7. 编译器优化级别-O2的含义是（  ）
     A. 无优化    B. 基本优化    C. 全面优化    D. 激进优化

  8. SIMD是指（  ）
     A. 单指令单数据    B. 单指令多数据
     C. 多指令单数据    D. 多指令多数据

  9. 以下哪个不是存储层次优化的方法（  ）
     A. 循环展开    B. Cache分块    C. 预取    D. 按行访问数组

  10. 暗硅问题产生的主要原因是（  ）
     A. 晶体管数量不足    B. 功耗限制
     C. 制程工艺落后    D. 存储容量不足

==== 二、填空题 ====

  1. CPU执行时间的计算公式为：CPU时间 = _______ × _______ × _______。

  2. 基准测试程序SPEC CPU分为______和______两类，分别测试整数和浮点性能。

  3. Amdahl定律的公式为：加速比 = _______。

  4. 存储层次优化的主要目标是提高______局部性和______局部性。

  5. 常见的并行技术包括______级并行、______级并行和______级并行。

  6. 动态功耗公式：P = _______ × _______ × _______。

  7. 能效比是______与______的比值。

  8. DVFS是指______。

  9. 80/20法则指的是______。

  10. TOP500排名使用______基准测试。

==== 三、计算题 ====

  1. 某程序在A机器上运行时间为10秒，A机器的时钟频率为2GHz。在B机器上运行该程序需要8秒。问：
     (1) B机器比A机器快多少倍？
     (2) 如果两台机器的CPI相同，B机器的时钟频率是多少？

  2. 某计算机运行某程序，各类指令的比例和CPI如下：
    - ALU指令：40%，CPI=1
    - Load指令：20%，CPI=2
    - Store指令：10%，CPI=2
    - 分支指令：20%，CPI=3
    - 浮点指令：10%，CPI=5
    
    计算：
    (1) 该程序的CPI是多少？
    (2) 如果时钟频率为2GHz，执行10亿条指令需要多少时间？

  3. 某程序运行时间为100秒，其中乘法运算占30秒。如果乘法运算速度提高2倍，总加速比是多少？改进后的执行时间是多少？

  4. 某程序中可并行部分占75%，串行部分占25%。问：
    (1) 使用4个核能获得多少加速比？
    (2) 使用无限多核，最大加速比是多少？

==== 四、简答题 ====

  1. 简述响应时间和吞吐量的区别与联系。

  2. 什么是CPI？影响CPI的因素有哪些？

  3. 简述Amdahl定律及其在性能优化中的指导意义。

  4. 列举三种常用的性能优化技术，并简要说明原理。

  5. 什么是功耗墙？为什么会出现功耗墙？

  6. 简述暗硅问题及其应对策略。

----

**参考答案**：

一、选择题：1.B  2.C  3.B  4.C  5.B  6.B  7.C  8.B  9.A  10.B

二、填空题：
  1. 指令数、CPI、时钟周期（或 指令数、CPI、1/时钟频率）
  2. SPECint、SPECfp
  3. 1 / [(1-可改进比例) + 可改进比例/部件加速比]
  4. 时间、空间
  5. 指令、线程、数据
  6. C、V²、f（电容、电压平方、频率）
  7. 性能、功耗
  8. 动态电压频率调节（Dynamic Voltage and Frequency Scaling）
  9. 20%的代码占用了80%的执行时间（或80%的效果来自20%的原因）
  10. LINPACK

三、计算题：
  1. (1) 性能比 = 10/8 = 1.25倍；(2) 2.5GHz
  2. (1) CPI = 1×0.4 + 2×0.2 + 2×0.1 + 3×0.2 + 5×0.1 = 2.1；(2) 1.05秒
  3. 加速比 = 1/(0.7+0.15) = 1.18；执行时间 = 85秒
  4. (1) 加速比 = 1/(0.25+0.75/4) = 2.29；(2) 最大加速比 = 1/0.25 = 4

四、简答题：
  1. 响应时间是单个任务的完成时间，越短越好；吞吐量是单位时间完成的任务数，越大越好。通常减少响应时间会提高吞吐量，但在多处理器系统中，增加处理器可提高吞吐量而不改变单个任务的响应时间。

  2. CPI是每条指令的平均时钟周期数。影响因素包括：指令类型、流水线效率、Cache命中率、分支预测准确率等。

  3. Amdahl定律指出系统加速比受限于可改进部分的比例。指导意义：优化应集中在占用时间多的部分；优化有极限；并行化受串行部分限制。

  4. (1)编译器优化：自动重排指令、内联函数等；(2)算法优化：选择更优算法降低复杂度；(3)Cache优化：改善数据访问模式提高Cache命中率。

  5. 功耗墙是芯片功耗密度过高导致散热困难的问题。因为功耗与频率和电压平方成正比，而频率提升需要提高电压，导致功耗急剧增加。

  6. 暗硅是由于功耗限制，芯片上部分晶体管不能同时工作。应对策略包括使用专用加速器、近阈值计算、3D堆叠等。
Detach Close
您访问的页面并不存在。如果允许，您可以使用创建该页面按钮来创建它。