fix image url 2

lzzsG · Aug 2, 2024 · 32e9654 · 32e9654
1 parent 57b1f5a
commit 32e9654
Show file tree

Hide file tree

Showing 15 changed files with 113 additions and 113 deletions.
diff --git a/docs/L01 Intro.md b/docs/L01 Intro.md
@@ -17,31 +17,31 @@ Dan Garcia教授介绍了课程的主题——“计算机体系结构中的伟
 
 Garcia教授还特别指出，这门课程不仅仅关注单个计算机的工作原理，而是要从更广阔的视角，探讨在云端和移动设备等多种环境中计算机如何运作。
 
-![image-20240429195107400](./assets/image-20240429195107400.png)
+![image-20240429195107400]({{ site.baseurl }}/docs/assets/image-20240429195107400.png)
 
 ---
 
-![image-20240429203333905](./assets/image-20240429203333905.png)
+![image-20240429203333905]({{ site.baseurl }}/docs/assets/image-20240429203333905.png)
 
 ## 计算机体系结构中的 6 个伟大构想
 
 ### No.1  抽象化（Abstraction ）
 
 抽象化是计算机科学中一个核心概念，它允许我们在不考虑底层细节的情况下，处理复杂的问题和系统。在这门课程中，抽象化的讨论从Python编程语言的使用案例开始，强调了在编程中对函数、库、值等元素的命名和使用。这种抽象化的思维方式同样适用于硬件设计，例如，将所有信息编码为二进制数（0和1），这是数字逻辑和计算机硬件设计的基础。此外强调了从上至下连续抽象的重要性，即每一层的抽象都建立在下一层的抽象之上。
 
-![image-20240429204110137](./assets/image-20240429204110137.png)
+![image-20240429204110137]({{ site.baseurl }}/docs/assets/image-20240429204110137.png)
 
 ### No.2 摩尔定律（ Moore’s Law）
 
 摩尔定律是由英特尔联合创始人戈登·摩尔在1965年提出的，预测了集成电路上可容纳的晶体管数量大约每两年翻一番。这个定律不仅预示了技术的进步速度，还影响了计算成本的下降和计算能力的提升，从而推动了计算机架构和技术创新的快速发展。在课程中，通过展示从1972年的Intel 8008芯片到后来的Pentium芯片晶体管数量的爆炸性增长，直观展示了摩尔定律的实际效果。同时，讨论了摩尔定律如何成为芯片制造商的一种自我实现的预言，即他们总是以这个定律为目标，不断推动技术的极限。
 
-![moores](./assets/moores.jpg)
+![moores]({{ site.baseurl }}/docs/assets/moores.jpg)
 
 ### No.3 局部性原理（Principle of Locality/Memory Hierarchy）
 
 局部性原理是计算机科学中的一个重要概念，它解释了为什么近距离存取数据比远距离存取数据要快得多。这一原理通过一个与人类大脑回忆过程相类比的例子来阐述：从大脑快速回忆近期信息，到较慢地回想起较远处或久远的信息，类似于从计算机的寄存器（最快）、缓存（较快）、主内存（较慢）、硬盘（最慢）中取数据的过程。这种类比帮助学生理解，在设计计算机系统时如何通过优化数据存取的“局部性”来提升系统性能。这种层次化的存储系统确保了高效访问频繁使用的数据，同时在成本和性能之间取得平衡。
 
-![image-20240429203909041](./assets/image-20240429203909041.png)
+![image-20240429203909041]({{ site.baseurl }}/docs/assets/image-20240429203909041.png)
 
 ### No.4 并行性（Parallelism）
 
@@ -55,7 +55,7 @@ Garcia教授还特别指出，这门课程不仅仅关注单个计算机的工
 
 这些并行处理方式大幅度提高了处理效率，但也受到Amdahl定律的限制，该定律指出，一个程序的加速比最终受限于其必须顺序执行的部分。即使增加处理单元数量，总体性能提升也受到顺序执行代码部分的制约。
 
-![para3](./assets/para3.jpg)
+![para3]({{ site.baseurl }}/docs/assets/para3.jpg)
 
 ### No.5 性能测量与提升（Performance Measurement and Improvement）
 

diff --git a/docs/L02 Number Representation.md b/docs/L02 Number Representation.md
@@ -18,7 +18,7 @@ nav_order: 2
 
 进一步，教授解释了数字数据可以表示的各种内容，如字符、颜色和情绪等。强调了位（bit）的概念，即计算机中用于存储和处理信息的基本单位。每个位可以是0或1，通过组合位，可以表示更多的信息，例如5位可以有32种不同的设置，足以编码26个字母。
 
-![image-20240430143236301](./assets/image-20240430143236301.png)
+![image-20240430143236301]({{ site.baseurl }}/docs/assets/image-20240430143236301.png)
 
 ###  Bits can represent anything!!
 
@@ -94,7 +94,7 @@ E. 无限个比特位
 “哦，你一定是使用4进制。我使用10进制。”
 “不，我使用10进制。4进制是什么？”
 
-![image-20240430141505448](./assets/image-20240430141505448.png)
+![image-20240430141505448]({{ site.baseurl }}/docs/assets/image-20240430141505448.png)
 
 这部分通过一幅幽默的漫画来解释数制的相对性。漫画中有两个角色，一个外星人和一个宇航员。外星人声称有10块石头，而宇航员误以为外星人是使用4进制，因为在10进制中10块石头就是10。这里的笑话在于，不同的数制中"10"代表的数量可能不同，但每个数制中的居民都认为他们使用的是“10进制”。
 
@@ -264,7 +264,7 @@ Literals (not supported by all compilers):
 - 通常不显示前导零
 - 如果加法（或 -、*、/）的结果不能被这些最右边的硬件位表示，我们说**溢出**发生了
 
-![image-20240430134902023](./assets/image-20240430134902023.png)
+![image-20240430134902023]({{ site.baseurl }}/docs/assets/image-20240430134902023.png)
 
 在数字表示中，二进制位模式并不直接等同于它们所代表的数字，而是作为数字的抽象表达。在计算机科学中，数字是以二进制形式表达的，这称为数码。数码可以有无限长的位数，尽管我们通常只看到数值的有效位。当进行数值运算时，如果结果超出了硬件所能表示的位数范围，就会发生溢出。溢出是计算机科学中常见的问题，需要特别注意处理，以避免错误和不精确的计算结果。
 
@@ -348,7 +348,7 @@ Literals (not supported by all compilers):
   - = -8 + 5
   - = -3_{10}
 
-![image-20240430140716709](./assets/image-20240430140716709.png)
+![image-20240430140716709]({{ site.baseurl }}/docs/assets/image-20240430140716709.png)
 
 二的补码公式允许在有限的位数内准确地表示正数和负数。在这个例子中，我们看到了如何在4位二进制数（一个半字节）中表示十进制数-3。最高位的1表示负号，并且是2的3次方的负数。然后，每个后续位的值是2的相应次方乘以该位的值。最终结果显示了，尽管二进制表示似乎复杂，但通过这种方法可以精确地进行数值的算术计算。
 
@@ -361,7 +361,7 @@ Literals (not supported by all compilers):
 
 二的补码数“线”是指以环形方式排列的二进制数，可以用于解释在有限的N位中能够表示的正数和负数的数量。当N=5时，我们可以表示2^{N-1}（或者16）个非负数和同样多的负数。在这个环中，有一个零，其余的位分别表示从-16（10000）到15（01111）的数。这种环形的表示法有助于理解二的补码如何能够在有限位数中循环表示数字，也展示了正数和负数之间的对称性。
 
-![image-20240430141035724](./assets/image-20240430141035724.png)
+![image-20240430141035724]({{ site.baseurl }}/docs/assets/image-20240430141035724.png)
 
 ### 偏移编码：N = 5（偏移量 = -15）
 
@@ -374,7 +374,7 @@ Literals (not supported by all compilers):
 
 偏移编码是一种数字表示方法，它通过给无符号数加上一个偏差（或偏移量）来表示负数。在这种情况下，N位二进制数的偏差被设定为 -(2^{N-1})，例如，当N=5时，偏差为-15。这种方法类似于模拟信号处理中如何从一系列正数信号中产生负数，例如通过调整信号的中心点。在偏移编码中，只有一个零的表示，这样可以避免二进制表示法中的双零问题。
 
-![image-20240430141125200](./assets/image-20240430141125200.png)
+![image-20240430141125200]({{ site.baseurl }}/docs/assets/image-20240430141125200.png)
 
 ### L02B 最佳表示-12.75的方式是什么？（解释移动二进制点）
 

diff --git a/docs/L03 C Intro - Basics.md b/docs/L03 C Intro - Basics.md
@@ -69,7 +69,7 @@ C语言的一个核心特性是它允许程序员直接与硬件对话，并进
 > - **汇编**：虽然在这张图中未详细说明，但在编译过程中，汇编是一个必要的步骤。源代码首先会被编译器转换为汇编代码，然后汇编器将汇编代码转换为机器码。
 > - **链接器的作用**：链接器的作用是将多个目标文件（可能是程序的不同模块）以及必要的库文件组合在一起，生成最终的可执行文件。这一步骤是必要的，因为程序通常分为多个模块，编译生成多个目标文件后，需要通过链接器将它们结合起来，形成一个完整的可执行程序。
 
-![image-20240503212633211](./assets/image-20240503212633211.png)
+![image-20240503212633211]({{ site.baseurl }}/docs/assets/image-20240503212633211.png)
 
 ## 文件协作与编译过程
 
@@ -120,7 +120,7 @@ C语言的一个核心特性是它允许程序员直接与硬件对话，并进
      >
      > 这意味着，即使并行化的部分很大，如果串行部分的时间占比很小，整体加速效果仍然会受到限制。
 
-![image-20240503212704542](./assets/image-20240503212704542.png)
+![image-20240503212704542]({{ site.baseurl }}/docs/assets/image-20240503212704542.png)
 
 
 
@@ -156,11 +156,11 @@ C语言的一个核心特性是它允许程序员直接与硬件对话，并进
 
 这部分内容对C语言和Java语言进行了比较。Java是一种面向对象的编程语言，强调封装和对象的管理，而C语言则是以函数为中心的，更注重具体函数的操作而不是对象。这两种语言在内存管理上有本质的差异：Java具有自动垃圾收集机制，可以自动管理内存，而C语言需要程序员显式地使用malloc和free等函数来管理内存。这种差异使得Java在编写代码时可能更为简便，但C语言在性能和底层操作上提供了更大的灵活性和控制力。
 
-![image-20240503212744860](./assets/image-20240503212744860.png)
+![image-20240503212744860]({{ site.baseurl }}/docs/assets/image-20240503212744860.png)
 
-![image-20240503212807408](./assets/image-20240503212807408.png)
+![image-20240503212807408]({{ site.baseurl }}/docs/assets/image-20240503212807408.png)
 
-![image-20240503212830130](./assets/image-20240503212830130.png)
+![image-20240503212830130]({{ site.baseurl }}/docs/assets/image-20240503212830130.png)
 
 ### 1. 语言类型与编程单元
 
@@ -373,7 +373,7 @@ C语言虽然是一种较老的编程语言，但通过不断的更新和改进
 | long         | 较长的整数，至少32位          | 0, 78, -217, 301720971 |
 | long long    | 更长的整数，至少64位          | 31705192721092512      |
 
-![image-20240503213002534](./assets/image-20240503213002534.png)
+![image-20240503213002534]({{ site.baseurl }}/docs/assets/image-20240503213002534.png)
 
 
 
@@ -569,7 +569,7 @@ C语言提供了强大的语法和结构来支持高级编程需求，如数据
 
 计算正弦函数值的表格，并输出角度和对应的正弦值。
 
-![image-20240503213414565](./assets/image-20240503213414565.png)
+![image-20240503213414565]({{ site.baseurl }}/docs/assets/image-20240503213414565.png)
 
 这段C程序的主要功能是计算并打印从0度到360度的正弦值（Sine values）。代码分析如下：
 

diff --git a/docs/L04 C Intro - Pointers, Arrays, Strings.md b/docs/L04 C Intro - Pointers, Arrays, Strings.md
@@ -562,7 +562,7 @@ int main() {
    - 假设 `ptr2` 指向一个已初始化的 `Coord` 结构体 `{3, 4}`，其地址为 `0x100`。
    - 执行 `ptr1 = ptr2;` 后，`ptr1` 也指向地址 `0x100`，即与 `ptr2` 指向相同的结构体。
 
-![image-20240728220143258](./assets/image-20240728220143258.png)
+![image-20240728220143258]({{ site.baseurl }}/docs/assets/image-20240728220143258.png)
 
 #### 选择题解释
 
@@ -1055,7 +1055,7 @@ printf("*a: %d, a: %x, &a: %x\n", *a, a, &a);
      - 2字节（16位）的数据类型（如 `short`）通常对齐到2字节边界。
      - 1字节（8位）的数据类型（如 `char`）可以存储在任何地址上。
 
-![image-20240728220556327](./assets/image-20240728220556327.png)
+![image-20240728220556327]({{ site.baseurl }}/docs/assets/image-20240728220556327.png)
 
 ### 示例图示
 

diff --git a/docs/L05 Memory (Mis)Management.md b/docs/L05 Memory (Mis)Management.md
@@ -47,7 +47,7 @@ int main() {
 
 - **0x00000000** 部分是不可写/不可读的，因此在访问 `NULL` 指针时会崩溃。这种保护机制帮助捕捉对无效指针的访问。
 
-![image-20240730092540737](./assets/image-20240730092540737.png)
+![image-20240730092540737]({{ site.baseurl }}/docs/assets/image-20240730092540737.png)
 
 ## Where are variables allocated?
 
@@ -114,7 +114,7 @@ void d (int p) {
 
 在这个例子中，当`main()`调用`a()`时，栈上会分配一个新的栈帧用于`a()`。然后`a()`调用`b()`，分配新的栈帧用于`b()`。依次类推，直到调用`d()`。在`d()`执行完后，`d()`的栈帧被移除，返回到`c()`，再依次回到`b()`、`a()`和`main()`，实现后进先出。
 
-![image-20240730094149780](./assets/image-20240730094149780.png)
+![image-20240730094149780]({{ site.baseurl }}/docs/assets/image-20240730094149780.png)
 
 ## Passing Pointers into the Stack
 
@@ -522,7 +522,7 @@ void free_mem_y() {
 
 ### 堆管理示例
 
-![image-20240730111140251](./assets/image-20240730111140251.png)
+![image-20240730111140251]({{ site.baseurl }}/docs/assets/image-20240730111140251.png)
 
 请求 R1，100 字节  ->  请求 R2，10 字节  ->  释放 R1 的内存  ->  请求 R3，50 字节
 

diff --git a/docs/L06 Floating Point.md b/docs/L06 Floating Point.md
@@ -57,7 +57,7 @@ nav_order: 6
   - 计算方式：\\(1 \times 2^1 + 0 \times 2^0 + 1 \times 2^{-1} + 0 \times 2^{-2} + 1 \times 2^{-3} + 0 \times 2^{-4}\\)
   - 即：\\(2 + 0.5 + 0.125 = 2.625\\)
 
-![image-20240730131919273](./assets/image-20240730131919273.png)
+![image-20240730131919273]({{ site.baseurl }}/docs/assets/image-20240730131919273.png)
 
 **使用上述6位“固定二进制点”表示法的范围：**
 
@@ -78,7 +78,7 @@ nav_order: 6
 - 例如，计算 \\(1.1000 \times 0.0100\\)
   - 结果为：\\(0.1100\\)
 
-![image-20240730131847561](./assets/image-20240730131847561.png)
+![image-20240730131847561]({{ site.baseurl }}/docs/assets/image-20240730131847561.png)
 
 **需要记住二进制点的位置：**
 
@@ -108,7 +108,7 @@ nav_order: 6
   1. 存储这些“有效位”（significant bits）。
   2. 记录最高有效位（MSB）左侧 2 位的二进制小数点（“指数字段”）。
 
-![image-20240730132906720](./assets/image-20240730132906720.png)
+![image-20240730132906720]({{ site.baseurl }}/docs/assets/image-20240730132906720.png)
 
 **二进制点** 独立于有效位存储，因此可以表示非常大和非常小的数字。通过分离有效位和指数，我们可以动态调整二进制点的位置，从而扩展表示范围。
 
@@ -126,7 +126,7 @@ nav_order: 6
 - 尾数（mantissa）：1.640625
 - 指数（exponent）：-1
 
-![image-20240730133729508](./assets/image-20240730133729508.png)
+![image-20240730133729508]({{ site.baseurl }}/docs/assets/image-20240730133729508.png)
 
 ## Enter Scientific Notation (in Binary)
 
@@ -177,7 +177,7 @@ nav_order: 6
 **浮点数表示形式：**
 - (-1)<sup>s</sup> × (1 + significand) × 2<sup>(exponent-127)</sup>
 
-![image-20240730134907827](./assets/image-20240730134907827.png)
+![image-20240730134907827]({{ site.baseurl }}/docs/assets/image-20240730134907827.png)
 
 ### 详细解释
 
@@ -366,7 +366,7 @@ nav_order: 6
 -3.4×10^38 ---- -1.2×10^-38 ---- 0 ---- 1.2×10^-38 ---- 3.4×10^38
 ```
 
-![image-20240730142300993](./assets/image-20240730142300993.png)
+![image-20240730142300993]({{ site.baseurl }}/docs/assets/image-20240730142300993.png)
 
 **如果数字超出此范围会怎样？**
 
@@ -450,7 +450,7 @@ s 1111 1111 xxx...xxxxx
 
 由于使用了归一化形式和隐含的1，在零附近的表示间隔较大，导致数值精度不足。
 
-![image-20240730143147625](./assets/image-20240730143147625.png)
+![image-20240730143147625]({{ site.baseurl }}/docs/assets/image-20240730143147625.png)
 
 ## Denorms: Gradual Underflow (2/2)
 
@@ -484,7 +484,7 @@ s 0000 0000 xxx...xxxxx
 
 非规范化数允许表示更接近零的数值，提供了更高的精度，避免了在接近零时出现的数值间隙。
 
-![image-20240730145436728](./assets/image-20240730145436728.png)
+![image-20240730145436728]({{ site.baseurl }}/docs/assets/image-20240730145436728.png)
 
 > ## 规范化数与非规范化数的设计逻辑
 >
@@ -608,7 +608,7 @@ s 0000 0000 xxx...xxxxx
   - **指数（Exponent）**：11位
   - **有效数字（Significand）**：52位
 
-![image-20240730151048083](./assets/image-20240730151048083.png)
+![image-20240730151048083]({{ site.baseurl }}/docs/assets/image-20240730151048083.png)
 
 **双精度（vs. 单精度）**
 
@@ -681,13 +681,13 @@ s 0000 0000 xxx...xxxxx
 - **BFLOAT16**（半精度浮点数的变种）：用于深度学习，保留了FP32的指数范围，但减少了有效数字的位数，以更快地进行训练。
 - **TF32**（张量浮点数）：主要用于张量计算，结合了FP16和FP32的特点，提升了计算速度和效率。
 
-![image-20240730151304138](./assets/image-20240730151304138.png)
+![image-20240730151304138]({{ site.baseurl }}/docs/assets/image-20240730151304138.png)
 
 ## Who Uses What in Domain Accelerators?
 
 ### 域加速器中谁使用什么？
 
-![image-20240730151406513](./assets/image-20240730151406513.png)
+![image-20240730151406513]({{ site.baseurl }}/docs/assets/image-20240730151406513.png)
 
 - 各种域加速器采用不同的浮点数表示形式以优化特定的计算任务。
   - 例如，Google TPU v2和v3广泛使用int8和fp16用于机器学习加速。

diff --git a/docs/L07 Intro to Assembly Language, RISC-V.md b/docs/L07 Intro to Assembly Language, RISC-V.md
@@ -247,13 +247,13 @@ sw x3, 4(x10)
 
 **硬件架构描述（例如，块图）：**
 
-![image-20240731104022846](./assets/image-20240731104022846.png)
+![image-20240731104022846]({{ site.baseurl }}/docs/assets/image-20240731104022846.png)
 
 - 硬件架构描述包括CPU的设计和功能模块。块图显示了处理器的各个部分如何连接和交互。
 
 **逻辑电路描述（电路原理图）：**
 
-![image-20240731104106063](./assets/image-20240731104106063.png)
+![image-20240731104106063]({{ site.baseurl }}/docs/assets/image-20240731104106063.png)
 
 - 电路原理图描述了物理电路的布局和连接方式。这一步骤详细描述了实际硬件组件如何实现逻辑功能。
 
@@ -414,7 +414,7 @@ add x1, x2, x3
 - **寄存器（Registers）**：用于存储数据和指令，直接内置于处理器中，非常快速。
 - **算术逻辑单元（Arithmetic Logic Unit, ALU）**：执行算术和逻辑运算。
 
-![image-20240731105619891](./assets/image-20240731105619891.png)
+![image-20240731105619891]({{ site.baseurl }}/docs/assets/image-20240731105619891.png)
 
 寄存器直接在硬件中，因此速度非常快（比0.25纳秒更快）。
 
@@ -553,7 +553,7 @@ RISC-V: sub x4, x5, x6   # x4 = x5 - x6
 C:      d = e - f;
 ```
 
-![image-20240731112615998](./assets/image-20240731112615998.png)
+![image-20240731112615998]({{ site.baseurl }}/docs/assets/image-20240731112615998.png)
 
 **重要提示：**