冯诺依曼计算机模型

​ 现代计算机模型基于-冯诺依曼计算机模型

​ 计算机在运行时，先从内存中取出第一条指令，通过控制器的译码，按指令的要求，从存储器中取出数据进行指定的运算和逻辑操作等加工，然后再按地址把结果送到内存中去。接下来，再取出第二条指令，在控制器的指挥下完成规定操作。依此进行下去。直至遇到停止指令。

​ 程序与数据一样存贮，按程序编排的顺序，一步一步地取出指令，自动地完成指令规定的操作是计算机最基本的工作模型。这一原理最初是由美籍匈牙利数学家冯.诺依曼于1945年提出来的，故称为冯.诺依曼计算机模型。

计算机五大核心组成部分

  1. 控制器(Control)：是整个计算机的中枢神经，其功能是对程序规定的控制信息进行解释，根据其要求进行控制，调度程序、数据、地址，协调计算机各部分工作及内存与外设的访问等。

  2. 运算器(Datapath)：运算器的功能是对数据进行各种算术运算和逻辑运算，即对数据进行加工处理。

  3. 存储器(Memory)：存储器的功能是存储程序、数据和各种信号、命令等信息，并在需要时提供这些信息。

  4. 输入(Input system)：输入设备是计算机的重要组成部分，输入设备与输出设备合你为外部设备，简称外设，输入设备的作用是将程序、原始数据、文字、字符、控制命令或现场采集的数据等信息输入到计算机。常见的输入设备有键盘、鼠标器、光电输入机、磁带机、磁盘机、光盘机等。

  5. 输出(Output system)：输出设备与输入设备同样是计算机的重要组成部分，它把外算机的中间结果或最后结果、机内的各种数据符号及文字或各种控制信号等信息输出出来。微机常用的输出设备有显示终端CRT、打印机、激光印字机、绘图仪及磁带、光盘机等。

下图为冯诺依曼计算机模型图：

img

上图的模型在现代计算机的硬件设计上体现如下：

image-20211117200709746

对于软件来说，我们并不需要关系上面所有的内容，侧重于CPU和内存即可。

CPU与内存

CPU

CPU内部结构

CPU内部可以分为如下三个部分：

  • 控制单元

​ 控制单元是整个CPU的指挥控制中心，由指令寄存器IR（Instruction Register）、指令译码器ID（Instruction Decoder）和 操作控制器OC（Operation Controller） 等组成，对协调整个电脑有序工作极为重要。它根据用户预先编好的程序，依次从存储器中取出各条指令，放在指令寄存器IR中，通过指令译码（分析）确定应该进行什么操作，然后通过操作控制器OC，按确定的时序，向相应的部件发出微操作控制信号。操作控制器OC中主要包括：节拍脉冲发生器、控制矩阵、时钟脉冲发生器、复位电路和启停电路等控制逻辑。

  • 运算单元

​ 运算单元是运算器的核心。可以执行算术运算（包括加减乘数等基本运算及其附加运算）和逻辑运算（包括移位、逻辑测试或两个值比较）。相对控制单元而言，运算器接受控制单元的命令而进行动作，即运算单元所进行的全部操作都是由控制单元发出的控制信号来指挥的，所以它是执行部件。

  • 数据单元

​ 存储单元包括 CPU 片内缓存Cache和寄存器组，是 CPU 中暂时存放数据的地方，里面保存着那些等待处理的数据，或已经处理过的数据，CPU 访问寄存器所用的时间要比访问内存的时间短。 寄存器是CPU内部的元件，寄存器拥有非常高的读写速度，所以在寄存器之间的数据传送非常快。采用寄存器，可以减少 CPU 访问内存的次数，从而提高了 CPU 的工作速度。寄存器组可分为专用寄存器和通用寄存器。专用寄存器的作用是固定的，分别寄存相应的数据；而通用寄存器用途广泛并可由程序员规定其用途。

image-20211117201003430

CPU缓存结构

现代计算机为了提升执行效率，减少CPU与内存的交互，一般会在CPU上集成多级缓存，目前最常见的为三级缓存结构：

  • L1 Cache，分为数据缓存和指令缓存，逻辑核独占
  • L2 Cache，物理核独占，逻辑核共享
  • L3 Cache，所有物理核共享

image-20211117201318060

存储器存储空间大小：内存>L3>L2>L1>寄存器；

存储器速度快慢排序：寄存器>L1>L2>L3>内存；

PS：缓存由最小的存储区块-缓存行（cacheline）组成，缓存行的大小通常为64byte。

CPU读取存储器数据过程

1、CPU要取寄存器X的值，只需要一步：直接读取。

2、CPU要取L1 cache的某个值，需要1-3步（或者更多）：把cache行锁住，把某个数据拿来，解锁，如果没锁住就慢了。

3、CPU要取L2 cache的某个值，先要到L1 cache里取，L1当中不存在，在L2里，L2开始加锁，加锁以后，把L2里的数据复制到L1，再执行读L1的过程，上面的3步，再解锁。

4、CPU取L3 cache的也是一样，只不过先由L3复制到L2，从L2复制到L1，从L1到CPU。

5、CPU取内存则最复杂：通知内存控制器占用总线带宽，通知内存加锁，发起内存读请求，等待回应，回应数据保存到L3（如果没有就到L2），再从L3/2到L1，再从L1到CPU，之后解除总线锁定。

为什么要有高速缓存？

​ CPU在摩尔定律的指导下以每18个月翻一番的速度在发展，然而内存和硬盘的发展速度远远不及CPU。这就造成了高性能能的内存和硬盘价格及其昂贵。然而CPU的高度运算需要高速的数据。为了解决这个问题，CPU厂商在CPU中内置了少量的高速缓存以解决I/O速度和CPU运算速度之间的不匹配问题。

局部性原理

​ 在CPU访问存储设备时，无论是存取数据抑或存取指令，都趋于聚集在一片连续的区域中，这就被称为局部性原理。

时间局部性（Temporal Locality）：如果一个信息项正在被访问，那么在近期它很可能还会被再次访问。

比如循环、递归、方法的反复调用等。

空间局部性（Spatial Locality）：如果一个存储器的位置被引用，那么将来他附近的位置也会被引用（虽然可能不使用，但是CPU仍可能会一次性加载当前及其附近的数据到缓存中）。

比如顺序执行的代码、连续创建的两个对象、数组等。

空间局部性例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
public class SpatialLocalityTest {

    private static int size1 = 100;
    private static int size2 = 1024 * 1024;

    private static Integer[][] arr = new Integer[size1][size2];

    public static void main(String[] args) {

        for (int i = 0; i < size1; i++) {
            for (int j = 0; j < size2; j++) {
                arr[i][j] = 1;
            }
        }

        int sum = 0;
        long startTime = System.currentTimeMillis();
        for (int i = 0; i < size1; i++) {
            for (int j = 0; j < size2; j++) {
                sum += arr[i][j];
            }
        }
        long endTime = System.currentTimeMillis();
        System.out.println("time:" + (endTime - startTime)  + "  sum:" + sum);

        sum = 0;
        startTime = System.currentTimeMillis();

        for (int i = 0; i < size2; i++) {
            for (int j = 0; j < size1; j++) {
                sum += arr[j][i];
            }
        }
        endTime = System.currentTimeMillis();
        System.out.println("time:" + (endTime - startTime)  + "  sum:" + sum);
    }
}
// 运行结果
time:92  sum:104857600
time:136  sum:104857600

从结果中我们能看到第二种循环的效率更低，又因为数组是连续存储的，方案一在加载时，CPU会一次性加载多个数据到缓存，减少CPU和内存的交互，而方案二的读取方式不符合空间局部性原则，所以自然而然效率就低了。

CPU运行安全等级

CPU有4个运行等级：

  • ring0
  • ring1
  • ring2
  • ring3

​ Linux与Windows只用到了2个级别:ring0、ring3，操作系统内部内部程序指令通常运行在ring0级别，操作系统以外的第三方程序运行在ring3级别。

​ 第三方程序如果要调用操作系统内部函数功能，由于运行安全级别不够，必须切换CPU运行状态，从ring3切换到ring0，然后执行系统函数。JVM创建在线程操作时，线程阻塞唤醒都是重型操作就是因为CPU要切换运行状态。

JVM创建线程CPU的工作过程如下：

  1. CPU从ring3切换ring0创建线程
  2. 创建完毕,CPU从ring0切换回ring3
  3. 线程执行JVM程序
  4. 线程执行完毕，销毁还得切回ring0

内存

操作系统为了做到程序运行安全隔离与稳定，将内存空间分为了用户空间和内核空间。

以32位操作系统，4G大小内存空间为例：

image-20211117205735395

​ Linux为内核代码和数据结构预留了几个页框，这些页永远不会被转出到磁盘上。从 0x00000000 到 0xC0000000（PAGE_OFFSET） 的线性地址可由用户代码 和 内核代码进行引用（即用户空间）。从0xC0000000（PAGE_OFFSET）到 0xFFFFFFFFF的线性地址只能由内核代码进行访问（即内核空间）。内核代码及其数据结构都必须位于这 1 GB的地址空间中，但是对于此地址空间而言，更大的消费者是物理地址的虚拟映射。

​ 这意味着在 4 GB 的内存空间中，只有 3 GB 可以用于用户应用程序。进程与线程只能运行在用户方式（usermode）或内核方式（kernelmode）下。用户程序运行在用户方式下，而系统调用运行在内核方式下。在这两种方式下所用的堆栈不一样：用户方式下用的是一般的堆栈(用户空间的堆栈)，而内核方式下用的是固定大小的堆栈（内核空间的堆栈，一般为一个内存页的大小），即每个进程与线程其实有两个堆栈，分别运行与用户态与内核态。

线程模型

CPU调度的基本单位线程，也划分为：

内核线程模型（KLT）

image-20211117210054118

内核线程(KLT)：系统内核管理线程(KLT)，内核保存线程的状态和上下文信息，线程阻塞不会引起进程阻塞。在多处理器系统上，多线程在多处理器上并行运行。线程的创建、调度和管理由内核完成，效率比ULT要慢，比进程操作快。

用户线程模型（ULT）

image-20211117210139017

用户线程(ULT)：用户程序实现，不依赖操作系统核心，应用提供创建、同步、调度和管理线程的函数来控制用户线程。不需要用户态/内核态切换，速度快。内核对ULT无感知，线程阻塞则进程（包括它的所有线程）阻塞。

JVM使用的是KTL线程模型

进程与线程

什么是进程？

​ 现代操作系统在运行一个程序时，会为其创建一个进程；例如QQ、微信等。进程是操作系统资源分配的最小单位。

什么是线程？

​ 线程是操作系统调度CPU的最小单元，也叫轻量级进程（Light Weight Process），在一个进程里可以创建多个线程，这些线程都拥有各自的计数器、堆栈和局部变量等属性，并且能够访问共享的内存变量。

​ CPU可以利用时间片轮转的方式在线程上高速切换，让用户感觉到这些线程在同时执行。

串行、并发与并行

image-20200910195621396

线程上下文切换

​ 多线程编程中一般线程的个数都大于 CPU 核心的个数，而一个 CPU 核心在任意时刻只能被一个线程使用，为了让这些线程都能得到有效执行，CPU 采取的策略是为每个线程分配时间片并轮转的形式。当一个线程的时间片用完的时候就会重新处于就绪状态让给其他线程使用，这个过程就属于一次上下文切换。

​ 概括来说就是：当前任务在执行完 CPU 时间片切换到另一个任务之前会先保存自己的状态，以便下次再切换回这个任务时，可以再加载这个任务的状态。任务从保存到再加载的过程就是一次上下文切换。

​ 上下文切换通常是计算密集型的。也就是说，它需要相当可观的处理器时间，在每秒几十上百次的切换中，每次切换都需要纳秒量级的时间。所以，上下文切换对系统来说意味着消耗大量的 CPU 时间，事实上，可能是操作系统中时间消耗最大的操作。

​ Linux 相比与其他操作系统（包括其他类 Unix 系统）有很多的优点，其中有一项就是，其上下文切换和模式切换的时间消耗非常少。

虚拟机指令集架构

虚拟机的指令集架构主要分为一下两种：

1、栈指令集架构

2、寄存器指令集架构

栈指令集架构

  1. 设计和实现更简单，适用于资源受限的系统;
  2. 避开了寄存器的分配难题：使用零地址指令方式分配;
  3. 指令流中的指令大部分是零地址指令，其执行过程依赖与操作栈，指令集更小，编译器容易实现;
  4. 不需要硬件支持，可移植性更好,更好实现跨平台。

寄存器指令集架构

  1. 典型的应用是x86的二进制指令集：比如传统的PC以及Android的Davlik虚拟机。
  2. 指令集架构则完全依赖硬件，可移植性差。
  3. 性能优秀和执行更高效。
  4. 花费更少的指令去完成一项操作。
  5. 在大部分情况下，基于寄存器架构的指令集往往都以一地址指令、二地址指令和三地址指令为主，而基于栈式架构的指令集却是以零地址指令为主。