^-^
csapp.md
  1. 信息就是位加上下文
  2. 2 程序被其他程序翻译成不同的格式
  3. 运行hello程序
    1. 关于存储设配的
  4. 存储器层次结构
  5. 操作系统
    1. 进程

csapp的简单摸索

这是我学习csapp所做的笔记
如有错误请评论或邮箱告知
2567031030@qq.com
会按照书上的讲写笔记(因为我也从头开始看的)，但只会记录我觉得重要的

信息就是位加上下文

对于一个hello.c 文件

1
2
3
4
5
#include<stdio.h>
int main(){
    printf("hello,world\n");
    return 0;
}

使用od -t d1 hello.c

可以将hello.c以10进制看到

1
2
3
4
5
6
0000000   35  105  110   99  108  117  100  101   32   60  115  116  100  105  111   46
0000020  104   62   10   10  105  110  116   32  109   97  105  110   40   41   32  123
0000040   10   32   32  112  114  105  110  116  102   40   34  104  101  108  108  111
0000060   32  119  111  114  108  100   33   92  110   34   41   59   10   32   32  114
0000100  101  116  117  114  110   32   48   59   10  125   10
0000113

在计算机眼中

  1. 系统中的所有信息，都是由一串比特表示的(说到底都是01)。
  2. 区分不同数据的唯一方法是我们读到这些数据的上下文

例如:
在不同的上下文中，一个同样的字节序列可以表示一个整数，浮点数，字符串，或着机器指令

有一个例子可以证明，新建一个1.ppm

1
2
3
4
5
6
7
P3
4 4
255
0  0  0   100 0  0       0  0  0    255   0 255
0  0  0    0 255 175     0  0  0     0    0  0
0  0  0    0  0  0       0 15 175    0    0  0
255 0 255  0  0  0       0  0  0    255  255 255

这是一种图片格式.ppm

你可以看看这张图

2 程序被其他程序翻译成不同的格式

===========================================================

可以看一下图片

![从hello.c到hello](https://i.ibb.co/tpj2GLV/Deepin-Screenshot-select-area-20230722110544.png = 100x50)

由hello.c->hello.i

可以使用gcc -E 进行预处理

gcc -E hello.c -o hello.i

也可以使用cpp

hello.i->hello.s

可以使用gcc -S 进行编译，生成汇编代码

gcc -S hello.i -o hello.i

在这一阶段中编译器会进行优化,会发现汇编与C的语言代码不能一一对应

当然gcc 可以指定是否优化

hello.s->hello.o

使用gcc -c进行汇编，生成目标文件

gcc -c hello.s -o hello.o

hello.o->hello

链接生成可执行文件

gcc hello.o -o hello

这上面

可以用一句话

gcc hello.c -o hello

  • 预处理阶段

预处理(cpp)根据#字符开头的命令

  1. 如#include<stdio.h>把这个stdio.h的文件直接插入

  2. 如#define这种宏进行处理

  • 编译阶段

就是将c的代码转换为汇编的代码

  • 汇编阶段

将汇编代码转换为机器语言的指令,把这些指令打包成一种叫可重定位目标程序(relocatable object program)的格式

  • 链接阶段

hello程序调用了printf函数,printf函数是标准C库中的函数，

printf函数存在与一个名为printf.o的一个预预编译好了的目标文件中,

链接器(ld)就处理这种合并

(如果想要更多的查询关于gcc)

可以使用man gcc 进行观看

使用man gcc | vim -可以使用管道将man gcc传入vim进行观看

运行hello程序

未完待续.。。
date: 2023-07-23 18:31:00

一图抵万字,哈哈哈！

系统结构图
可以将硬件分：

  1. 总线
    贯穿整个系统的电子管道，称为总线.它携带信息字体并负责在各个部件间传输

  2. I/O 设备

就是除了总线，主存，处理器以外的都是(例如：键盘，鼠标，磁盘，显示器等网络是种特殊的I/O设配)

  1. 主存

是一个临时存储设配，在处理器执行期间，用来存放程序和程序处理的数据

可以从两方面视角来看计算机:计算机视角和用户视角(物理视角和逻辑视角)
物理视角:主存是由一组动态随机存取存储器(DRAM)芯片组成的
逻辑视角:存储器是一个线性的字节数组,每个字节都有其唯一的地址(数组索引)

  1. 处理器

就写一个概念吧
中央处理单元(cpu),是解释(或执行)存储在主存中的指令引擎
在shell上运行./hello
这个hello 是./hello
shell是一个命令行解释器，它输出一个提示符，等待输入一个命令行，然后执行这个命令
是用来与系统交互的

从键盘上读取hello的命令

这个使用了直接存储器存储(DMA)，数据可以不用通过处理器而直接从磁盘到达主存
从磁盘加载可执行文件到主存上

将输出字符串从存储器写到显示器

来看看流程

  1. 在shell 中输入./hello,shell程序将字符逐一读入寄存器,再将它存放在内存中(内存一般指的是主存)

  2. 在键盘上按回车时，shell 程序知道我们已经结束了命理的输入

  3. shell执行一系列指令来加载可执行的hello文件,这些指令将hello目标文件中的代码和数据从磁盘复制到主存

  4. 目标文件hello中的代码和数据加载到主存，处理器就开始执行hello程序的main程序中的机器语言指令

  5. 这些指令将“hello,world\n字符串中的字节从主存复制到寄存器文件，再从寄存器文件中复制到显示设配,最终显示到屏幕上

可以使用命令strace ./hello

在我的电脑上会显示

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
execve("./hello", ["./hello"], 0x7ffcdebfb7e0 /* 64 vars */) = 0
brk(NULL)                               = 0x55eb43cde000
arch_prctl(0x3001 /* ARCH_??? */, 0x7ffe3bbb3000) = -1 EINVAL (Invalid argument)
access("/etc/ld.so.preload", R_OK)      = -1 ENOENT (No such file or directory)
openat(AT_FDCWD, "/etc/ld.so.cache", O_RDONLY|O_CLOEXEC) = 3
newfstatat(3, "", {st_mode=S_IFREG|0644, st_size=186503, ...}, AT_EMPTY_PATH) = 0
mmap(NULL, 186503, PROT_READ, MAP_PRIVATE, 3, 0) = 0x7fd7fa95a000
close(3)                                = 0
openat(AT_FDCWD, "/usr/lib/libc.so.6", O_RDONLY|O_CLOEXEC) = 3
read(3, "\177ELF\2\1\1\3\0\0\0\0\0\0\0\0\3\0>\0\1\0\0\0\20:\2\0\0\0\0\0"..., 832) = 832
pread64(3, "\6\0\0\0\4\0\0\0@\0\0\0\0\0\0\0@\0\0\0\0\0\0\0@\0\0\0\0\0\0\0"..., 784, 64) = 784
newfstatat(3, "", {st_mode=S_IFREG|0755, st_size=1961632, ...}, AT_EMPTY_PATH) = 0
mmap(NULL, 8192, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x7fd7fa958000
pread64(3, "\6\0\0\0\4\0\0\0@\0\0\0\0\0\0\0@\0\0\0\0\0\0\0@\0\0\0\0\0\0\0"..., 784, 64) = 784
mmap(NULL, 2006640, PROT_READ, MAP_PRIVATE|MAP_DENYWRITE, 3, 0) = 0x7fd7fa76e000
mmap(0x7fd7fa790000, 1429504, PROT_READ|PROT_EXEC, MAP_PRIVATE|MAP_FIXED|MAP_DENYWRITE, 3, 0x22000) = 0x7fd7fa790000
mmap(0x7fd7fa8ed000, 360448, PROT_READ, MAP_PRIVATE|MAP_FIXED|MAP_DENYWRITE, 3, 0x17f000) = 0x7fd7fa8ed000
mmap(0x7fd7fa945000, 24576, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_DENYWRITE, 3, 0x1d6000) = 0x7fd7fa945000
mmap(0x7fd7fa94b000, 52848, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_ANONYMOUS, -1, 0) = 0x7fd7fa94b000
close(3)                                = 0
mmap(NULL, 8192, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x7fd7fa76c000
arch_prctl(ARCH_SET_FS, 0x7fd7fa959640) = 0
set_tid_address(0x7fd7fa959910)         = 33357
set_robust_list(0x7fd7fa959920, 24)     = 0
rseq(0x7fd7fa959f60, 0x20, 0, 0x53053053) = 0
mprotect(0x7fd7fa945000, 16384, PROT_READ) = 0
mprotect(0x55eb42bba000, 4096, PROT_READ) = 0
mprotect(0x7fd7fa9b9000, 8192, PROT_READ) = 0
prlimit64(0, RLIMIT_STACK, NULL, {rlim_cur=8192*1024, rlim_max=RLIM64_INFINITY}) = 0
munmap(0x7fd7fa95a000, 186503)          = 0
newfstatat(1, "", {st_mode=S_IFIFO|0600, st_size=0, ...}, AT_EMPTY_PATH) = 0
getrandom("\xb8\xd2\x6c\x88\x21\xbd\x4c\x5a", 8, GRND_NONBLOCK) = 8
brk(NULL)                               = 0x55eb43cde000
brk(0x55eb43cff000)                     = 0x55eb43cff000
write(1, "hello world!\n", 13)          = 13
hello world!
exit_group(0)                           = ?
+++ exited with 0 +++
strace: Exit of unknown pid 33354 ignored

这是chatgpt所说

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
41
42
43
44
45
46

根据提供的跟踪信息，以下是对程序执行的步骤进行逐步解释:

1. 尝试以读取方式打开文件 "/etc/ld.so.preload"，但该文件未找到（ENOENT - 没有此文件或目录）。

2. 成功以只读方式（O_RDONLY|O_CLOEXEC）打开文件 "/etc/ld.so.cache"，并获取了文件描述符 3。

3. 在文件描述符 3 上执行 "newfstatat" 系统调用，以获取有关文件的信息。获取到的信息表明该文件是一个具有读写权限的普通文件，大小为 186503 个字节。

4. 然后，程序使用 "mmap" 系统调用将文件 "/etc/ld.so.cache"（186503 个字节）的内容映射到内存中，采用只读保护（PROT_READ），映射内存区域的起始地址为 0x7fd7fa95a000。

5. 映射完成后，程序关闭了文件描述符 3，即 "/etc/ld.so.cache"。

6. 程序打开了文件 "/usr/lib/libc.so.6"，即 C 库文件，以进行读取。

7. 它将 C 库文件 ("/usr/lib/libc.so.6") 的前 832 个字节读入内存。

8. 使用 "pread64" 系统调用，程序从 libc 文件中读取 ELF 对象格式的内容表示。

9. 在文件描述符 3 上执行 "newfstatat" 系统调用，程序获取到 libc 文件的信息。获取到的信息表明该文件是一个具有读写权限的普通文件，大小为 1961632 个字节。

10. 程序使用 "mmap" 系统调用，将一个具有读写权限（PROT_READ|PROT_WRITE）的内存区域（8192 个字节）映射到内存中。映射内存区域的起始地址为 0x7fd7fa958000。

11. 使用 "pread64"，程序再次从 libc 文件读取 ELF 对象格式的内容表示。

12. 程序继续使用额外的 "mmap" 系统调用将 libc 文件的内容映射到不同权限的多个内存区域。

13. 将 libc 文件的文件描述符设置为关闭（文件描述符 3）。

14. 程序使用 "mmap" 系统调用分配一个新的具有读写权限的内存区域，大小为 8192 个字节。

15. 还进行了一些设置线程特定属性和程序属性的系统调用。

16. 程序使用 "mprotect" 系统调用在不同的内存区域上应用内存保护。

17. 程序使用 "getrandom" 系统调用获取随机字节序列。

18. 使用 "brk" 系统调用分配一个新的堆内存区域。

19. 使用类似的 "brk" 系统调用扩展堆内存区域。

20. 最后，程序向标准输出（文件描述符 1）写入字符串 "hello world!\n"。

21. 程序通过调用 "exit_group" 结束，状态码为 0，表示执行成功。

注意：跟踪还显示了一个未知进程（pid 33354）的退出被忽略，以及使用了 "prlimit64" 和 "munmap" 系统调用，这些与上述程序的行为无关。

我可以简单的看出是比较符合所说的

从这个示例看出来，系统花费大量的时间把信息从一个地方挪到一个地方

关于存储设配的

好累 这个书是真的有意思但讲不清

未完待续.。。
date: 2023-07-27 22:53:00

处理器从寄存器文件中读取数据比从主存读数度要快100倍以上,处理器与主存之间的距离速度还在增大
为了解决这些问题
系统设计者采用了更小更快的存储设备,称为高速缓存存储器(cache memory)
作为暂时的集结区存放处理器近期可能需要的信息

高速缓存的局部性原理,程序具有访问局部区域里的数据和代码的趋势,
通过让高速缓存存放可能经常访问的数据,大部分的内存操作都能在快速的高速缓存中完成

存储器层次结构

一图抵万字
存储器层次结构

操作系统

shell运行hello程序时,hello 程序输出自己消息时,shell 和hello程序会通过
操作系统进行访问键盘,显示器,磁盘,主存
操作系统是应用程序和硬件之间的一层软件,所有程序对于硬件的尝试都必须通过
操作系统
基本作用

  1. 防止硬件被失控的应用程序滥用
  2. 向程序提供简单一致的机制来控制复杂而又通常大不想同的低级硬件设备

操作系统通过几个基本的抽象概念(进程，虚拟内存和文件)来实现这两个功能
计算机系统的分层视图和操作系统的抽象表示

进程

进程是操作系统对一个正在运行的程序的一种抽象
一个系统上可以运行多个进程,每个进程都好像认为自己在独占的使用硬件
并发运行 是指一个进程的指令和另一个指令是交错运行的

在大多数系统中,需要的进程数是多于可以运行它们的cpu个数的.
传统的系统在一个时刻只能运行一个程序,而先进的多核处理器可以执行多个程序

2023-07-19 该篇文章被 apple115 打上标签: learn

© 1949-2024 China
🌊看过大海的人不会忘记海的广阔🌊 本站由Hexo驱动｜使用Hexo-theme-A4主题