[已解决]操作系统DMA概念问题

Max472

这里说的主存是什么？内存条？还是硬盘？往内存条写也要进行I/O操作吗？

最佳答案

月排行榜 / 总排行榜

人造人

2021-9-10 23:13:54

主存指的是内存

先看一个例子
现在有 2 个程序
程序 1 读取硬盘中的 100 个扇区数据，然后计算平均数
程序 2 计算 从 1 到 1000000 的所有质数和
如果不使用 dma，那就是先读取硬盘的扇区 0，然后读取硬盘的扇区 1，然后读取扇区 2，。。。
就是这样

1.     for(size_t i = 0; i < 100; ++i) {
   
2.         read_sector(&buff[i * 512], i); // 读取硬盘数据，读取结果存储到 buff 中
   
3.     }
   

复制代码

然后进行计算平均数
然后程序 1 结束
开始运行程序 2，计算 从 1 到 1000000 的所有质数和

如果使用 dma，那就是这样
先执行程序 1
程序 1 这样写

1.     dma_set_address(buff);      // 告诉 dma 把数据读取到 buff 中
   
2.     dma_set_start_sector(0);    // 告诉 dma 从扇区 0 开始读取
   
3.     dma_set_data_length(100);   // 告诉 dma 读取 100 个扇区的数据
   
4.     dma_start();                // 开始读取，上面 3 行只是设置 dma 的参数，这一行直接导致 dma 开始工作
   

复制代码

// 上面 4 行代码就是告诉 dma 读取硬盘，从扇区 0 开始读取，读取 100 个扇区，把读取的数据放在 buff 中

然后程序 1，执行一个 wait();
这个函数会挂起程序 1，直到 dma 完成任务

现在程序 1 暂停执行，启动程序 2，计算 从 1 到 1000000 的所有质数和
程序 2 可能计算到 80% 了，就快计算完成了
但是 dma 完成任务了，这时候程序 2 暂停，去执行程序 1，就是程序 1 中的那个 wait 函数返回了，然后执行 wait 函数下面的计算平均数的代码
完成后，程序 1 退出
然后返回到程序 2 继续执行剩下的 20% 的计算任务

第二个方案，因为使用了 dma，在读取硬盘数据的时候 cpu 去执行另一个程序了（程序 2）
而方案一中，程序 1 是一直循环读取硬盘的，读取硬盘是一个非常慢的过程，cpu 一直在等非常慢的硬盘，不能去做其他事（不能去执行程序 2）
肯定方案二更好，因为 cpu 不会去等非常慢的硬盘
其实 dma 也是这样工作的
先读取硬盘的扇区 0，然后读取硬盘的扇区 1，然后读取扇区 2，。。。
只不过是和 cpu 同时工作
dma 做 dma 的事情，读取硬盘的扇区 0，然后读取硬盘的扇区 1，然后读取扇区 2，。。。
cpu 执行 cpu 的程序，（程序 2）
两个同时工作，谁也不打扰谁

下面是程序 1 的两个版本的伪代码

1. void read_sector(char buff[], size_t index) {
   
2.     disk_set_sector(i);         // 告诉硬盘读取第 i 个扇区
   
3.     while(disk_status() == 0);  // 等待硬盘把数据准备好
   
4.     disk_read(buff);            // 从硬盘读取数据
   
5. }
   
6. 
   
7. void task1(void) {
   
8.     char buff[512 * 100];   // 一个扇区 512 个字节，一共有 100 个扇区
   
9.     for(size_t i = 0; i < 100; ++i) {
   
10.         read_sector(&buff[i * 512], i); // 读取硬盘数据，读取结果存储到 buff 中
    
11.     }
    
12. 
    
13.     // 下面计算 100 个扇区数据的平均数
    
14.     // ...
    
15. }
    
16. 
    
17. void task1_dma(void) {
    
18.     char buff[512 * 100];
    
19.     dma_set_address(buff);      // 告诉 dma 把数据读取到 buff 中
    
20.     dma_set_start_sector(0);    // 告诉 dma 从扇区 0 开始读取
    
21.     dma_set_data_length(100);   // 告诉 dma 读取 100 个扇区的数据
    
22.     dma_start();                // 开始读取，上面 3 行只是设置 dma 的参数，这一行直接导致 dma 开始工作
    
23.     wait();                     // 等待 dma 完成任务
    
24. 
    
25.     // 下面计算 100 个扇区数据的平均数
    
26.     // ...
    
27. }
    

复制代码

其实学习这些东西之前，应该先学习汇编语言
如果你没有用汇编语言读取过硬盘数据，真的很难理解这些概念

再举一个例子
一个公司有两个人
一个领导（cpu）
一个员工（dma）
有两个任务，写文案和跑业务
有两种方案
一、
领导先出去跑业务，跑完业务回来再写文案
那个员工就在公司坐着看，然后大喊 加油，^_^
二、
领导安排员工去跑业务，然后自己在公司写文案
过了很长时间，领导的文案写的也差不多了，员工也回来了
员工拿出一份文件递给领导说，这是这一次的数据
领导说，嗯，我一会处理这个，现在没你什么事了，一边凉快去，之后有事的时候再找你
然后领导简单的看了看那份数据，他决定先写完当前这个文案，然后再去处理那份数据
cpu 完全可以选择先把程序 2 剩下的 20% 算完，然后再去处理程序 1 剩下的部分

跳转到最佳答案楼层

人造人

主存指的是内存

先看一个例子
现在有 2 个程序
程序 1 读取硬盘中的 100 个扇区数据，然后计算平均数
程序 2 计算 从 1 到 1000000 的所有质数和
如果不使用 dma，那就是先读取硬盘的扇区 0，然后读取硬盘的扇区 1，然后读取扇区 2，。。。
就是这样

1.     for(size_t i = 0; i < 100; ++i) {
   
2.         read_sector(&buff[i * 512], i); // 读取硬盘数据，读取结果存储到 buff 中
   
3.     }
   

复制代码

然后进行计算平均数
然后程序 1 结束
开始运行程序 2，计算 从 1 到 1000000 的所有质数和

如果使用 dma，那就是这样
先执行程序 1
程序 1 这样写

1.     dma_set_address(buff);      // 告诉 dma 把数据读取到 buff 中
   
2.     dma_set_start_sector(0);    // 告诉 dma 从扇区 0 开始读取
   
3.     dma_set_data_length(100);   // 告诉 dma 读取 100 个扇区的数据
   
4.     dma_start();                // 开始读取，上面 3 行只是设置 dma 的参数，这一行直接导致 dma 开始工作
   

复制代码

// 上面 4 行代码就是告诉 dma 读取硬盘，从扇区 0 开始读取，读取 100 个扇区，把读取的数据放在 buff 中

然后程序 1，执行一个 wait();
这个函数会挂起程序 1，直到 dma 完成任务

现在程序 1 暂停执行，启动程序 2，计算 从 1 到 1000000 的所有质数和
程序 2 可能计算到 80% 了，就快计算完成了
但是 dma 完成任务了，这时候程序 2 暂停，去执行程序 1，就是程序 1 中的那个 wait 函数返回了，然后执行 wait 函数下面的计算平均数的代码
完成后，程序 1 退出
然后返回到程序 2 继续执行剩下的 20% 的计算任务

第二个方案，因为使用了 dma，在读取硬盘数据的时候 cpu 去执行另一个程序了（程序 2）
而方案一中，程序 1 是一直循环读取硬盘的，读取硬盘是一个非常慢的过程，cpu 一直在等非常慢的硬盘，不能去做其他事（不能去执行程序 2）
肯定方案二更好，因为 cpu 不会去等非常慢的硬盘
其实 dma 也是这样工作的
先读取硬盘的扇区 0，然后读取硬盘的扇区 1，然后读取扇区 2，。。。
只不过是和 cpu 同时工作
dma 做 dma 的事情，读取硬盘的扇区 0，然后读取硬盘的扇区 1，然后读取扇区 2，。。。
cpu 执行 cpu 的程序，（程序 2）
两个同时工作，谁也不打扰谁

下面是程序 1 的两个版本的伪代码

1. void read_sector(char buff[], size_t index) {
   
2.     disk_set_sector(i);         // 告诉硬盘读取第 i 个扇区
   
3.     while(disk_status() == 0);  // 等待硬盘把数据准备好
   
4.     disk_read(buff);            // 从硬盘读取数据
   
5. }
   
6. 
   
7. void task1(void) {
   
8.     char buff[512 * 100];   // 一个扇区 512 个字节，一共有 100 个扇区
   
9.     for(size_t i = 0; i < 100; ++i) {
   
10.         read_sector(&buff[i * 512], i); // 读取硬盘数据，读取结果存储到 buff 中
    
11.     }
    
12. 
    
13.     // 下面计算 100 个扇区数据的平均数
    
14.     // ...
    
15. }
    
16. 
    
17. void task1_dma(void) {
    
18.     char buff[512 * 100];
    
19.     dma_set_address(buff);      // 告诉 dma 把数据读取到 buff 中
    
20.     dma_set_start_sector(0);    // 告诉 dma 从扇区 0 开始读取
    
21.     dma_set_data_length(100);   // 告诉 dma 读取 100 个扇区的数据
    
22.     dma_start();                // 开始读取，上面 3 行只是设置 dma 的参数，这一行直接导致 dma 开始工作
    
23.     wait();                     // 等待 dma 完成任务
    
24. 
    
25.     // 下面计算 100 个扇区数据的平均数
    
26.     // ...
    
27. }
    

复制代码

其实学习这些东西之前，应该先学习汇编语言
如果你没有用汇编语言读取过硬盘数据，真的很难理解这些概念

再举一个例子
一个公司有两个人
一个领导（cpu）
一个员工（dma）
有两个任务，写文案和跑业务
有两种方案
一、
领导先出去跑业务，跑完业务回来再写文案
那个员工就在公司坐着看，然后大喊 加油，^_^
二、
领导安排员工去跑业务，然后自己在公司写文案
过了很长时间，领导的文案写的也差不多了，员工也回来了
员工拿出一份文件递给领导说，这是这一次的数据
领导说，嗯，我一会处理这个，现在没你什么事了，一边凉快去，之后有事的时候再找你
然后领导简单的看了看那份数据，他决定先写完当前这个文案，然后再去处理那份数据
cpu 完全可以选择先把程序 2 剩下的 20% 算完，然后再去处理程序 1 剩下的部分

人造人

往内存条写也要进行I/O操作吗？
cpu 操作内存中的数据不需要进行 I/O 操作
cpu 自己读取硬盘，需要通过 I/O 端口告诉硬盘一些参数
通过 dma 读取
cpu 需要通过 I/O 端口告诉 dma 一些参数，dma 要通过 I/O 端口告诉硬盘一些参数
我想 dma 应该也是通过 I/O 端口和硬盘打交道的，这个我也不清楚

Max472

人造人 发表于 2021-9-10 23:13
主存指的是内存

先看一个例子

不采用dma的时候cpu在读取硬盘扇区的时候，是通过中断方式进行I/O操作的吧
如果这样，在读取的时候，由于进程的并发性，cpu不应该在程序1进行I/O操作的时候切换到程序2进行计算吗
程序1读完1个扇区进行中断返回，cpu切换回程序1再进行读取扇区2
是这样吗？

人造人

Max472 发表于 2021-9-11 14:30
不采用dma的时候cpu在读取硬盘扇区的时候，是通过中断方式进行I/O操作的吧
如果这样，在读取的时候，由 ...

嗯，程序 1 也可以这么写，但是还是没有程序 2 效率高
程序 1 的 cpu 会被打扰 100 次
而程序 2 只被打扰 1 次

Max472

人造人 发表于 2021-9-11 15:02
嗯，程序 1 也可以这么写，但是还是没有程序 2 效率高
程序 1 的 cpu 会被打扰 100 次
而程序 2 只被打 ...

人造人

Max472 发表于 2021-9-11 18:02

不对，就算是使用中断的方式读取硬盘数据
也是在硬盘准备数据的这段时间可以切换到其他程序去执行
等硬盘准备好了，处理器需要切回来，从硬盘的 io 端口两个字节两个字节的读取 256 次数据到内存
然后再切去别的程序，等下一个中断到来了，还要切回来，循环 256 次读取硬盘 io 端口
就是说，如果不使用 dma，处理器就需要从硬盘 io 端口，两个字节两个字节的读取数据到内存
这几天我找了好多相关的资料，自己也写程序验证了
之前回复你的，有一些是错误的，^_^

还有，书上，百度上说的，PC/AT 机器，dma 通道只有一个 SDLC 通信适配器（通道1） 和 一个 软盘驱动器（通道2），没有硬盘的
我在 bochs 上找到的是软盘的和 sb16（Sound Blaster 16）的，没有硬盘的
我在百度上找到了一个使用 PCI-IDE控制器 的
使用 dma 要枚举 pci 配置空间
或者改用 软盘
两个的代码量都有点多，而且考虑到要用汇编语言，我实在写不下去了，^_^
未来有机会的话，可以考虑用 C语言
学习这些东西之前要先学汇编语言，学了汇编语言你就可以使用汇编语言验证你的猜想

1.     .code16
   
2.     .globl  _start
   
3. _start:
   
4.     ljmpw   $0x07c0, $1f
   
5. 1:  xorw    %ax, %ax
   
6.     movw    %ax, %ss
   
7.     movw    $0x7c00, %sp
   
8. 
   
9.     callw   interrupt_init
   
10.     callw   register_disk_interrupt
    
11.     callw   enable_disk_interrupt
    
12. 
    
13.     # 全局变量初始化
    
14.     # flag = 0;
    
15.     movb    $0, %cs:0   # 就把它放在这里，这不会有任何问题
    
16. 
    
17.     # 读取从扇区 0 开始的 8 个扇区到 ds:si 指定的位置
    
18.     movw    $0x07e0, %ax
    
19.     movw    %ax, %ds
    
20.     xorw    %si, %si
    
21.     movw    $8, %cx
    
22.     xorw    %bx, %bx
    
23.     callw   read_sect
    
24. 
    
25.     movw    $0xb800, %ax
    
26.     movw    %ax, %ds
    
27.     movb    o', 0x06e0
    
28.     movb    k', 0x06e2
    
29.     movb    $0x04, 0x06e1
    
30.     movb    $0x04, 0x06e3
    
31. 
    
32.     cli
    
33.     hlt
    
34. 3:  jmp     3b
    
35. 
    
36. # void read_sect(uint8_t *buff, size_t start_sect, size_t count);
    
37. # buff -> ds:si
    
38. # start_sect -> bx
    
39. # count -> cx
    
40. read_sect:
    
41.     pushw   %ax
    
42.     pushw   %cx
    
43.     pushw   %dx
    
44.     pushw   %si
    
45.     pushw   %bx
    
46.     # 读取 count 个扇区
    
47.     movb    %cl, %al
    
48.     movw    $0x01f2, %dx
    
49.     outb    %al, (%dx)
    
50.     # 发送逻辑扇区号
    
51.     movb    %bl, %al
    
52.     movw    $0x01f3, %dx
    
53.     outb    %al, (%dx)
    
54.     movb    %bh, %al
    
55.     movw    $0x01f4, %dx
    
56.     outb    %al, (%dx)
    
57.     movb    $0, %al
    
58.     movw    $0x01f5, %dx
    
59.     outb    %al, (%dx)
    
60.     movb    $0xe0, %al      # 主盘，LBA 模式
    
61.     movw    $0x01f6, %dx
    
62.     outb    %al, (%dx)
    
63.     # 发送读命令
    
64.     movb    $0x20, %al
    
65.     movw    $0x01f7, %dx
    
66.     outb    %al, (%dx)
    
67. 
    
68.     movw    %cx, %bx
    
69.     # 等待硬盘准备好
    
70. 1:  movb    %cs:0, %al
    
71.     cmpb    $1, %al
    
72.     jne     1b
    
73.     movb    $0, %cs:0
    
74.     # 从硬盘读取数据
    
75.     xorw    %cx, %cx
    
76.     movw    $0x01f0, %dx
    
77. 2:  inw     (%dx), %ax
    
78.     movw    %ax, (%si)
    
79.     addw    $2, %si
    
80.     incw    %cx
    
81.     cmpw    $256, %cx       # 512 字节，256 个字
    
82.     jb      2b
    
83.     decw    %bx
    
84.     cmpw    $0, %bx
    
85.     jne     1b
    
86. 
    
87.     popw    %bx
    
88.     popw    %si
    
89.     popw    %dx
    
90.     popw    %cx
    
91.     popw    %ax
    
92.     retw
    
93. 
    
94. # void interrupt_init(void);
    
95. interrupt_init:
    
96.     cli
    
97.     pushw   %ax
    
98.     pushw   %cx
    
99.     pushw   %dx
    
100.     pushw   %si
     
101.     pushw   %ds
     
102.     # ICW1: 边沿触发/级联方式
     
103.     movb    $0x11, %al
     
104.     movw    $0x20, %dx
     
105.     outb    %al, (%dx)
     
106.     # ICW2: 起始中断向量
     
107.     movb    $0x20, %al
     
108.     movw    $0x21, %dx
     
109.     outb    %al, (%dx)
     
110.     # ICW3: 从片级联到IR2
     
111.     movb    $0x04, %al
     
112.     movw    $0x21, %dx
     
113.     outb    %al, (%dx)
     
114.     # ICW4: 非总线缓存/特殊全嵌套/非自动结束
     
115.     movb    $0x11, %al
     
116.     movw    $0x21, %dx
     
117.     outb    %al, (%dx)
     
118.     # ICW1: 边沿触发/级联方式
     
119.     movb    $0x11, %al
     
120.     movw    $0xa0, %dx
     
121.     outb    %al, (%dx)
     
122.     # ICW2: 起始中断向量
     
123.     movb    $0x28, %al
     
124.     movw    $0xa1, %dx
     
125.     outb    %al, (%dx)
     
126.     # ICW3: 从片级联到IR2
     
127.     movb    $0x02, %al
     
128.     movw    $0xa1, %dx
     
129.     outb    %al, (%dx)
     
130.     # ICW4: 非总线缓存/普通全嵌套/非自动结束
     
131.     movb    $0x01, %al
     
132.     movw    $0xa1, %dx
     
133.     outb    %al, (%dx)
     
134. 
     
135.     # 设置默认中断
     
136.     xorw    %cx, %cx
     
137.     movw    %cx, %ds
     
138.     movw    $0x20 * 4, %si
     
139.     movw    $ignore_interrupt, %ax
     
140.     movw    %cs, %dx
     
141. 1:  movw    %ax, (%si)
     
142.     movw    %dx, 2(%si)
     
143.     addw    $4, %si
     
144.     incw    %cx
     
145.     cmpw    $16, %cx
     
146.     jb      1b
     
147. 
     
148.     popw    %ds
     
149.     popw    %si
     
150.     popw    %dx
     
151.     popw    %cx
     
152.     popw    %ax
     
153.     sti
     
154.     retw
     
155. 
     
156. # void ignore_interrupt(void);
     
157. ignore_interrupt:
     
158.     pushw   %ax
     
159.     pushw   %dx
     
160.     # 发送 OCW2
     
161.     movb    $0x20, %al
     
162.     movw    $0xa0, %dx
     
163.     outb    %al, (%dx)
     
164.     movb    $0x20, %al
     
165.     movw    $0x20, %dx
     
166.     outb    %al, (%dx)
     
167.     popw    %dx
     
168.     popw    %ax
     
169.     iretw
     
170. 
     
171. # void register_disk_interrupt(void);
     
172. register_disk_interrupt:
     
173.     cli
     
174.     pushw   %ax
     
175.     pushw   %dx
     
176.     pushw   %ds
     
177.     xorw    %ax, %ax
     
178.     movw    %ax, %ds
     
179.     movw    $disk_interrupt, %ax
     
180.     movw    %cs, %dx
     
181.     # IRQ14
     
182.     movw    %ax, 0xb8
     
183.     movw    %dx, 0xba
     
184.     popw    %ds
     
185.     popw    %dx
     
186.     popw    %ax
     
187.     sti
     
188.     retw
     
189. 
     
190. # void disk_interrupt(void);
     
191. disk_interrupt:
     
192.     pushw   %ax
     
193.     pushw   %dx
     
194.     # 读取硬盘状态
     
195.     movw    $0x01f7, %dx
     
196.     inb     (%dx), %al
     
197.     andb    $0x88, %al
     
198.     cmpb    $0x08, %al
     
199.     jne     1f
     
200. 
     
201.     # 硬盘数据准备好了
     
202.     # flag = 1;
     
203.     movb    $1, %cs:0
     
204. 1:
     
205.     # 发送 OCW2
     
206.     movb    $0x20, %al
     
207.     movw    $0xa0, %dx
     
208.     outb    %al, (%dx)
     
209.     movb    $0x20, %al
     
210.     movw    $0x20, %dx
     
211.     outb    %al, (%dx)
     
212.     popw    %dx
     
213.     popw    %ax
     
214.     iretw
     
215. 
     
216. # void enable_disk_interrupt(void);
     
217. enable_disk_interrupt:
     
218.     pushw   %ax
     
219.     pushw   %dx
     
220.     movb    $0x00, %al
     
221.     movw    $0x03f6, %dx
     
222.     outb    %al, (%dx)
     
223.     popw    %dx
     
224.     popw    %ax
     
225.     retw
     

复制代码

Max472

人造人 发表于 2021-9-13 18:00
不对，就算是使用中断的方式读取硬盘数据
也是在硬盘准备数据的这段时间可以切换到其他程序去执行
等硬 ...