Linux内存的缺页与置换

最新推荐文章于 2022-03-14 13:54:14 发布
最新推荐文章于 2022-03-14 13:54:14 发布
阅读量1w 收藏 6
点赞数 1
分类专栏： linux 文章标签： linux command python user bash signal
一)缺页

当CPU请求一个不在RAM中的内存页时,会发生缺页,比如我们从内存读取/写入数据,而数据未在内存,此时都会发生缺页.

我们通过下面的程序对内存缺页情况进行测试,程序通过分配大块内存以供程序使用,该程序只访问一次内存就不再使用它,
它的做法是通过malloc分配内存,并在每页修改1个字节,然后进入睡眠状态.
注:Linux非常灵敏,它不提供任何物理存储给未被修改过的页,所以我们必须在一个已分配区域的每页中读出或写入至少1个字节,来消耗内存中的页.

测试程序hog.c如下:
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>

int
main (int argc, char *argv[])
{
        if (argc != 2)
                exit (0);

        size_t mb = strtoul(argv[1],NULL,0);

        size_t nbytes = mb * 0x100000;
        char *ptr = (char *) malloc(nbytes);
        if (ptr == NULL){
                perror("malloc");
                exit (EXIT_FAILURE);
        }

        size_t i;
        const size_t stride = sysconf(_SC_PAGE_SIZE);
        for (i = 0;i < nbytes; i+= stride) {
                ptr[i] = 0;
        }

        printf("allocated %d mb\n", mb);
        pause();
        return 0;
}

编译
gcc  hog.c -o hog

查看当前的内存
free -m
             total       used       free     shared    buffers     cached
Mem:           503        206        296          0         30        140
-/+ buffers/cache:         36        467
Swap:         1027          0       1027

我们通过使用GNU time命令来查看缺页的次数
\time ./hog 100
allocated 100 mb
Command terminated by signal 2
0.00user 3.12system 0:04.52elapsed 69%CPU (0avgtext+0avgdata 0maxresident)k
0inputs+0outputs (0major+25719minor)pagefaults 0swaps

注:
25719minor表示缺页25719次,每次4KB,正好是100MB的内存分配.

major表示主缺页,主缺页是要求输入/输出到磁盘的缺页.
minor表示次缺页,次缺页是任何其它的缺页.



二)置换

置换是指程序请求内存,而物理内存不足时,内核将被迫把缺页存储到置换分区,也就是说,它将最近最少使用的页面(LRU)置换到SWAP.
如果SWAP不足,或没有SWAP,就会发生内存分配失败.如下:
swapoff -a
./hog 500 &
[1] 2901
malloc: Cannot allocate memory

[1]+  Exit 1                  ./hog 500

下面看看置换的发生,先查看当前的内存.
swapon -a
free -m  
             total       used       free     shared    buffers     cached
Mem:           503         43        459          0          0          9
-/+ buffers/cache:         33        469
Swap:         1027          0       1027

现在有469MB的空闲空间,此时我们通过hog程序,请求500MB的内存空间,将会发生置换,如下
\time ./hog 500 
allocated 500 mb(程序pause在这里,要用CTRL+C中断才能看到下面的信息,在这之间我们可以在另一个终端查看内存空间)
Command terminated by signal 2
0.02user 3.53system 0:07.19elapsed 49%CPU (0avgtext+0avgdata 0maxresident)k
0inputs+0outputs (0major+128142minor)pagefaults 0swaps

在另一个终端用free查看内存如下:
free -m
             total       used       free     shared    buffers     cached
Mem:           503        497          6          0          0          3
-/+ buffers/cache:        493          9
Swap:         1027         53        974
这里我们看到产生了53MB的内存置换.

回到第一个终端,我们看到缺页的信息是:0major+128142minor
这0个主缺页是指当进程请求一个驻留在磁盘上的页时,才发生主缺页,在这种情况下,页面不存在,因此它们没有驻留在磁盘上,所以不被计入主缺页数.
虽然hog进程引起系统向磁盘写入页,但实际上它没有把那些页写入磁盘,实际写入是由kswapd完成的.kswapd内核线程负责把数据从内存移到磁盘的烦琐工作,
只有当拥有那些页的进程再次调用它们时才会产生一个主缺页.


三)top命令

top命令是周期性的更新.
下面介绍几个top命令的使用技巧.

1)切换显示命令名称和完整命令

输入c

2)根据驻留内存大小进行排序

输入M

3)根据CPU使用百分比大小进行排序

输入P


4)根据时间/累计时间进行排序

输入T


5)显示线程

输入H


6)将top的信息划分为4个屏幕,分别DEF,Job,Mem,Usr

输入Shift+A

1:Def - 12:50:16 up  1:14,  2 users,  load average: 0.00, 0.01, 0.00
Tasks:  72 total,   2 running,  70 sleeping,   0 stopped,   0 zombie
Cpu(s):  0.0%us,  5.6%sy,  0.0%ni, 94.4%id,  0.0%wa,  0.0%hi,  0.0%si,  0.0%st
Mem:    515600k total,    72684k used,   442916k free,     3372k buffers
Swap:  1052248k total,    23140k used,  1029108k free,    48128k cached

1  PID USER      PR  NI  VIRT  RES  SHR S %CPU %MEM    TIME+  COMMAND                                                               
   138 root      13  -5     0    0    0 S  0.0  0.0   0:04.23 [kswapd0]                                                             
  2569 root      15   0  8216  664  436 R  5.6  0.1   0:02.69 sshd: root@pts/0,pts/1                                                
  2463 root      18   0  1924  160  140 S  0.0  0.0   0:02.32 hald-addon-storage: polling /dev/hdc                                  
  2405 root      15   0 25188 6180 1792 S  0.0  1.2   0:02.23 /usr/bin/python /usr/sbin/yum-updatesd                                
  2439 haldaemo  18   0  5348  640  392 S  0.0  0.1   0:01.81 hald                                                                  
     1 root      15   0  2032  160  140 S  0.0  0.0   0:01.18 init [3]                                                              
  3234 root      15   0  2164 1000  796 R  0.0  0.2   0:00.95 top                                                                   
  2422 avahi     15   0  3696  352  260 S  0.0  0.1   0:00.94 avahi-daemon: running [test1.local]                                   
   323 root      10  -5     0    0    0 S  0.0  0.0   0:00.75 [kjournald]                                                           
2  PID  PPID    TIME+  %CPU %MEM  PR  NI S  VIRT SWAP  RES  UID COMMAND                                                             
  3234  2721   0:00.95  0.0  0.2  15   0 R  2164 1164 1000    0 top                                                                 
  2721  2569   0:00.29  0.0  0.2  15   0 S  4620 3812  808    0 bash                                                                
  2571  2569   0:00.45  0.0  0.1  16   0 S  4616 4020  596    0 bash                                                                
  2569  2271   0:02.69  5.6  0.1  15   0 R  8216 7552  664    0 sshd                                                                
  2539     1   0:00.01  0.0  0.0  24   0 S  1624 1524  100    0 mingetty                                                            
  2516     1   0:00.01  0.0  0.0  24   0 S  1624 1524  100    0 mingetty                                                            
  2515     1   0:00.01  0.0  0.0  24   0 S  1628 1528  100    0 mingetty                                                            
  2514     1   0:00.00  0.0  0.0  18   0 S  1624 1524  100    0 mingetty                                                            
  2511     1   0:00.00  0.0  0.0  18   0 S  1624 1524  100    0 mingetty                                                            
3  PID %MEM  VIRT SWAP  RES CODE DATA  SHR nFLT nDRT S  PR  NI %CPU COMMAND                                                         
  2405  1.2 25188  18m 6180    4 8688 1792  264    0 S  15   0  0.0 yum-updatesd                                                    
  3234  0.2  2164 1164 1000   52  344  796    0    0 R  15   0  0.0 top                                                             
  1866  0.2  9612 8672  940    4 1664  512   72    0 S  12  -3  0.0 python                                                          
  2721  0.2  4620 3812  808  684  400  620   77    0 S  15   0  0.0 bash                                                            
  2235  0.1 12716  11m  672    4 3656  376   75    0 S  15   0  0.0 python                                                          
  2569  0.1  8216 7552  664  368  736  436   90    0 R  15   0  5.6 sshd                                                            
  2439  0.1  5348 4708  640  260 1908  392   66    0 S  18   0  0.0 hald                                                            
  2571  0.1  4616 4020  596  684  396  452   84    0 S  16   0  0.0 bash                                                            
  1549  0.1  2280 1768  512  432  420  392   31    0 S  15   0  0.0 dhclient                                                        
4  PID  PPID  UID USER     RUSER    TTY         TIME+  %CPU %MEM S COMMAND                                                          
  2371     1   43 xfs      xfs      ?          0:00.07  0.0  0.0 S xfs                                                              
  1941     1   32 rpc      rpc      ?          0:00.01  0.0  0.0 S portmap                                                          
  2405     1    0 root     root     ?          0:02.23  0.0  1.2 S yum-updatesd                                                     
  3234  2721    0 root     root     pts/1      0:00.95  0.0  0.2 R top                                                              
  1866  1864    0 root     root     ?          0:00.30  0.0  0.2 S python                                                           
  2721  2569    0 root     root     pts/1      0:00.29  0.0  0.2 S bash                                                             
  2235     1    0 root     root     ?          0:00.24  0.0  0.1 S python                                                           
  2569  2271    0 root     root     ?          0:02.69  5.6  0.1 R sshd                                                             
  2571  2569    0 root     root     pts/0      0:00.45  0.0  0.1 S bash  

可以自定义选择要定义的屏幕的显示字段,比如我们要Mem屏幕增加Time字段的显示,要进行如下操作.

首先输入w切换窗口,使当前的屏幕为Mem,再输入f,将看到如下的信息.

Current Fields:  ANOPQRSTUVbcdefgjlmyzWHIKX  for window 3:Mem
Toggle fields via field letter, type any other key to return 

* A: PID        = Process Id
* N: %MEM       = Memory usage (RES)
* O: VIRT       = Virtual Image (kb)
* P: SWAP       = Swapped size (kb)
* Q: RES        = Resident size (kb)
* R: CODE       = Code size (kb)
* S: DATA       = Data+Stack size (kb)
* T: SHR        = Shared Mem size (kb)
* U: nFLT       = Page Fault count
* V: nDRT       = Dirty Pages count
  b: PPID       = Parent Process Pid
  c: RUSER      = Real user name
  d: UID        = User Id
  e: USER       = User Name
  f: GROUP      = Group Name
  g: TTY        = Controlling Tty
  j: P          = Last used cpu (SMP)
  l: TIME       = CPU Time
  m: TIME+      = CPU Time, hundredths
  y: WCHAN      = Sleeping in Function
  z: Flags      = Task Flags <sched.h>
* W: S          = Process Status
* H: PR         = Priority
* I: NI         = Nice value
* K: %CPU       = CPU usage
* X: COMMAND    = Command name/line


输入L,表示选择  l: TIME       = CPU Time,选择后将在被选项前出现*号,如:* L: TIME       = CPU Time,再输入Return,就可以在Mem屏看到time的信息了,如下:
3  PID %MEM  VIRT SWAP  RES CODE DATA  SHR nFLT nDRT   TIME S  PR  NI %CPU COMMAND                                                  
  2405  1.2 25188  18m 6180    4 8688 1792  264    0   0:02 S  15   0  0.0 yum-updatesd                                             
  3234  0.2  2164 1164 1000   52  344  796    0    0   0:01 R  15   0  0.7 top                                                      
  1866  0.2  9612 8672  940    4 1664  512   72    0   0:00 S  12  -3  0.0 python                                                   
  2721  0.2  4620 3812  808  684  400  620   77    0   0:00 S  15   0  0.0 bash                                                     
  2235  0.1 12716  11m  672    4 3656  376   75    0   0:00 S  15   0  0.0 python                                                   
  2569  0.1  8216 7552  664  368  736  436   90    0   0:02 S  15   0  0.0 sshd                                                     
  2439  0.1  5348 4708  640  260 1908  392   66    0   0:01 S  18   0  0.0 hald                                                     
  2571  0.1  4616 4020  596  684  396  452   84    0   0:00 S  16   0  0.0 bash                                                     
  1549  0.1  2280 1768  512  432  420  392   31    0   0:00 S  19   0  0.0 dhclient 
  
同样,我们也可以以指定的列进行排序,例如想将Mem屏以VIRT(虚拟内存)进行排序,进行下面的操作:
输入O(大写),表示排序.
看到只有N: %MEM       = Memory usage (RES)行有*号,说明现在选中的是内存的百分比.
我们输入O(大写),表示选中  o: VIRT       = Virtual Image (kb)如下:

Current Sort Field:  N  for window 3:Mem
Select sort field via field letter, type any other key to return 

  a: PID        = Process Id
  b: PPID       = Parent Process Pid
  c: RUSER      = Real user name
  d: UID        = User Id
  e: USER       = User Name
  f: GROUP      = Group Name
  g: TTY        = Controlling Tty
  h: PR         = Priority
  i: NI         = Nice value
  j: P          = Last used cpu (SMP)
  k: %CPU       = CPU usage
  l: TIME       = CPU Time
  m: TIME+      = CPU Time, hundredths
  N: %MEM       = Memory usage (RES)
* O: VIRT       = Virtual Image (kb)
  p: SWAP       = Swapped size (kb)
  q: RES        = Resident size (kb)
  r: CODE       = Code size (kb)
  s: DATA       = Data+Stack size (kb)
  t: SHR        = Shared Mem size (kb)
  u: nFLT       = Page Fault count
  v: nDRT       = Dirty Pages count
  w: S          = Process Status
  x: COMMAND    = Command name/line
  y: WCHAN      = Sleeping in Function
  z: Flags      = Task Flags <sched.h>
  
输入回车返回主屏后,就是以VIRT进行排序了,如下:
3  PID %MEM  VIRT SWAP  RES CODE DATA  SHR nFLT nDRT   TIME S  PR  NI %CPU COMMAND                                                  
  2405  1.2 25188  18m 6180    4 8688 1792  264    0   0:02 S  15   0  0.0 yum-updatesd                                             
  2235  0.1 12716  11m  672    4 3656  376   75    0   0:00 S  15   0  0.0 python                                                   
  2141  0.0 12692  12m  244   84  10m  188    1    0   0:00 S  25   0  0.0 pcscd                                                    
  1864  0.1 12048  11m  300   92  10m  220   14    0   0:00 S  16  -3  0.0 auditd                                                   
  2252  0.0  9644 9484  160  364  644  156    5    0   0:00 S  18   0  0.0 cupsd                                                    
  1866  0.2  9612 8672  940    4 1664  512   72    0   0:00 S  12  -3  0.0 python                                                   
  2190  0.1  9332 8868  464  196 7168  360   37    0   0:00 S  25   0  0.0 automount                                                
  2569  0.1  8216 7552  664  368  736  436   90    0   0:02 S  15   0  0.0 sshd                                                     
  2439  0.1  5348 4708  640  260 1908  392   66    0   0:01 S  18   0  0.0 hald   
  

四)内存缺页与置换的综合实例

为完成最后一个测试,我们把上个程序做了更改,加入了信号处理及时间输出,如下:
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <signal.h>
#include <time.h>
#include <unistd.h>
#include <sys/time.h>

void handler(int sig)
{
}

#define TIMESPEC2FLOAT(tv) ((double) (tv).tv_sec+(double) (tv).tv_nsec*1e-9)

int
main (int argc,char *argv[])
{
        if (argc != 2)
                exit(0);

        signal(SIGUSR1, handler);

        size_t mb = strtoul(argv[1], NULL, 0);
        size_t nbytes = mb * 0x100000;
        char *ptr = (char *) malloc (nbytes);

        if (ptr == NULL){
                perror("malloc");
                exit(EXIT_FAILURE);
        }

        int val = 0;
        const size_t stride = sysconf(_SC_PAGE_SIZE);

        while(1){
                int i;
                struct timespec t1, t2;

                clock_gettime(CLOCK_REALTIME, &t1);

                for (i = 0;i<nbytes; i += stride){
                        ptr[i] = val;
                }
                val++;

                clock_gettime(CLOCK_REALTIME, &t2);
                printf("touched %d mb; in %.6f sec\n", mb,
                        TIMESPEC2FLOAT(t2) - TIMESPEC2FLOAT(t1));

                pause();
        }
return 0;
}

编译源程序,并做这个程序的两个软链接,如下:
gcc -O2 -o son-of-hog son-of-hog.c -lrt
ln -s son-of-hog hog-a
ln -s son-of-hog hog-b

查看当前的内存:
free -m
             total       used       free     shared    buffers     cached
Mem:           503        185        317          0         10        140
-/+ buffers/cache:         35        468
Swap:         1027          0       1027

注:此时我们看到有468MB的空闲内存,这里面有140MB的cached和10MB的buffers

清空置换空间(swap):
swapoff -a
swapon -a
free -m
             total       used       free     shared    buffers     cached
Mem:           503         50        452          0          1         16
-/+ buffers/cache:         33        470
Swap:         1027          0       1027

我们执行hog-a,以此占用300MB的内存空间,查看它分配内存的时间:
./hog-a 300 &
[1] 2592
touched 300 mb; in 2.784745 sec

注:
这里分配300MB的内存共用了2.7秒多.这里面有换页和回收cache的时间.


对这个进程使用一个SIGUSR1将再次唤醒并访问内存:
kill -USR1 %1
touched 300 mb; in 0.010827 sec

注:
这里只用了10ms.

我们这时执行hog-b,看看它会占用多少时间:
./hog-b 300 & 
[2] 2601
touched 300 mb; in 4.432349 sec

注:
因为物理内存都被分配了,为给hog-b分配空间,系统做了置换处理,即将物理内存分配给hog-b,而将hog-a占用的内存置换到swap.

对hog-b发送SIGUSR1信号,再次唤醒程序,这时只用143ms
pkill -USR1 hog-b
touched 300 mb; in 0.143772 sec

我们用top命令来查看:

top -p $(pgrep hog-a) -p $(pgrep hog-b)

1:Def - 06:12:26 up 10 min,  1 user,  load average: 0.01, 0.10, 0.10
Tasks:   2 total,   0 running,   2 sleeping,   0 stopped,   0 zombie
Cpu(s):  0.0%us,  0.0%sy,  0.0%ni, 99.7%id,  0.3%wa,  0.0%hi,  0.0%si,  0.0%st
Mem:    515600k total,   509468k used,     6132k free,      956k buffers
Swap:  1052248k total,   162924k used,   889324k free,    11312k cached

1  PID USER      PR  NI  VIRT  RES  SHR S %CPU %MEM    TIME+  COMMAND                                                               
  2601 root      18   0  301m 300m  428 S  0.0 59.7   0:03.32 ./hog-b 300                                                           
  2592 root      18   0  301m 154m  428 S  0.0 30.7   0:02.76 ./hog-a 300                                                           
2  PID  PPID    TIME+  %CPU %MEM  PR  NI S  VIRT SWAP  RES  UID COMMAND                                                             
  2601  2553   0:03.32  0.0 59.7  18   0 S  301m 1112 300m    0 hog-b                                                               
  2592  2553   0:02.76  0.0 30.7  18   0 S  301m 147m 154m    0 hog-a                                                               
3  PID %MEM  VIRT SWAP  RES CODE DATA  SHR nFLT nDRT S  PR  NI %CPU COMMAND                                                         
  2601 59.7  301m 1112 300m    4 300m  428  235    0 S  18   0  0.0 hog-b                                                           
  2592 30.7  301m 147m 154m    4 300m  428    0    0 S  18   0  0.0 hog-a                                                           
4  PID  PPID  UID USER     RUSER    TTY         TIME+  %CPU %MEM S COMMAND                                                          
  2601  2553    0 root     root     pts/0      0:03.32  0.0 59.7 S hog-b                                                            
  2592  2553    0 root     root     pts/0      0:02.76  0.0 30.7 S hog-a 
  
这里做几个说明:
1)两个程序都用了300MB的虚拟内存.(VIRT 301m)
2)由于hog-a先运行,而后占用的内存数据被置换到swap,所以只占用了154MB的物理内存(RES 154MB),占用了147MB的SWAP空间(SWAP 147).
3)由于hog-b后运行,所以用抢占了hog-a的物理内存,此时它占用了300M的物理内存(RES 300MB),由于置换它产生了235次页错误(Page Fault count).
macky0668
关注
专栏目录
Linux内核：内存管理——内存页面置换
m0_74282605的博客
05-15 497
内存页面置换算法主要有下面这么几种：最佳页面置换算法基本思路是，置换在「未来」最长时间不访问的页面。所以，该算法实现需要计算内存中每个逻辑页面的「下一次」访问时间，然后比较，选择未来最长时间不访问的页面。我们举个例子，假设一开始有 3 个空闲的物理页，然后有请求的页面序列，那它的置换过程如下图：在这个请求的页面序列中，缺页共发生了 7 次（空闲页换入 3 次 + 最优页面置换 4 次），页面置换共发生了 4 次。这很理想，但是实际系统中无法实现，因为程序访问页面时是动态的，我们是无法预知每个页面在「下一次」
linux内存管理笔记(六）---请求缺页
奇小葩
02-03 1429
在上一章流程分析，引出了”请求调页“技术，事实上，对于进程，开始运行的时候，并不需要访问地址空间的全部内容。有一部分地址空间也许永远都不会被进程所使用，基于程序的局部性原理，在程序执行的每一个阶段，真正使用的进程页只有一小部分，对于临时用不到的页，其所在的页框可以由其他的进程使用。本章主要是从原理和代码层次来讨论，内核是怎么完成请求分页机制的实现原理。操作系统执行缺页处理程序后，获取磁盘地址，启动...
linux缺页异常详解
08-28
全面描述linux arm缺页异常的处理原理和处理方式，结合原理的解释描述以及全部相关的源码注释，深刻理解缺页异常
Linux的内存分页管理
weixin_33778778的博客
07-19 194
作者：Vamei 出处：http://www.cnblogs.com/vamei 严禁转载   内存是计算机的主存储器。内存为进程开辟出进程空间，让进程在其中保存数据。我将从内存的物理特性出发，深入到内存管理的细节，特别是了解虚拟内存和内存分页的概念。   内存 简单地说，内存就是一个数据货架。内存有一个最小的存储单位，大多数都是一个字节。内存用内存地址（memory address）来...
linux 内存缺页,Linux内核之内存管理(4)--缺页处理程序
weixin_28917337的博客
05-04 305
本文主要解说缺页处理程序，凝视足够具体，不再解释。//以下函数将一页内存页面映射到指定线性地址处，它返回页面的物理地址//把一物理内存页面映射到线性地址空间指定处或者说把线性地址空间指定地址address处的页面映射到主内存区页面page上。主要工作是在相关也文件夹项和页表项中设置指定页面的信息。在处理缺页异常函数do_no_page中会调用这个函数。參数：address--线性地址；page--...
linux 内存 缺页异常
老鹰不捉小鸡
03-14 1446
产生缺页异常中断的几种情况 当内存管理单元（MMU）中确实没有创建虚拟物理页映射关系，并且在该虚拟地址之后再没有当前进程的线性区（vma）的时候，可以肯定这是一个编码错误，这将杀掉该进程 当MMU中确实没有创建虚拟页物理页映射关系，并且在该虚拟地址之后存在当前进程的线性区vma的时候，这很可能是缺页中断，并且可能是栈溢出导致的缺页中断； 当使用malloc/mmap等希望访问物理空间的库函数/系统调用后，由于linux并未真正给新创建的vma映射物理页，此时若先进行写操作，将和2产生缺页中断的情况一样；若
linux 缺页统计
最新发布
01-04
Linux缺页统计是指Linux操作系统用于监控和记录系统内存缺页（Page Fault）情况的一种机制。缺页是指当程序访问的页面不在内存中时，会触发缺页中断，操作系统需要将页面从磁盘加载到内存中，以满足程序对该页面的...
linux系统缺页次数统计
06-08
在 Linux 系统中，可以使用 `vmstat` 命令来查看缺页次数的统计信息。在 `vmstat` 命令的输出中，可以看到 `si` 和 `so` 两个字段，它们分别表示从磁盘读取到内存的页面数量和从内存写入到磁盘的页面数量。如果这两...
操作系统 linux 请求分页 模拟内存管理实验报告java（内含源码）
07-06
在本实验报告中，我们将重点讨论Linux操作系统中的请求分页内存管理，这是一个模拟实验，旨在帮助理解内存管理的基本概念和技术。 请求分页是现代操作系统中广泛采用的一种内存管理策略，它允许进程在需要时请求页...
Linux内存管理主体框架分析.pdf
09-07
Linux内存管理是操作系统的核心组成部分，尤其对于Linux内核而言，其高效且灵活的内存管理机制是其能够在各种设备上广泛部署的关键。本文主要基于Linux内核2.4.18，探讨了Linux内存管理的主体框架，这对于理解和优化...
linux缺页系统
Belle_Chou的博客
01-05 289
点击打开链接
Linux——缺页中断与内存置换算法，你想知道的都在这里！
cckluv的博客
01-29 2239
Linux——缺页中断与内存置换算法，你想知道的都在这里！缺页中断页面置换算法缺页次数一、先进先出（FIFO）二.最近最久未使用（LRU）三、最佳置换算法（OPT） 缺页中断 缺页中断就是要访问的页不在主存，需要操作系统将其调入主存后再进行访问。在这个时候，被内存映射的文件实际上成了一个分页交换文件。 一句话概括：当前虚拟地址要找的数据不在物理内存中 页面置换算法 进程运行过程中，如果发生缺页中断，而此时内存中有没有空闲的物理块是，为了能够把所缺的页面装入内存，系统必须从内存中选择一页调出到磁盘的对换
linux内存管理笔记(七）---页面置换
奇小葩
02-06 1885
为了提高内存的利用率，解决内存供不应求的问题，更加合理的使用内存，引出了虚拟内存的概念。系统将内存暂时不需要的部分写入到硬盘，实现了对于扩展内存容量，所以叫虚拟内存，使得应用程序可以使用比实际物理内存更大的内存空间。前面我们了解了在进程运行过程中，当内存中存在空闲页的时候，系统如何实现这个虚拟内存管理的软硬件实现方式。如果内存中没有空闲页，那么就需要页面的调出，算法的好坏直接影响到系统的性能，本章...
linux内存管理-页面的换入
guoguangwu的专栏
10-18 553
在i386 CPU将一个线性地址映射成物理地址的过程中，如果该地址的映射已经建立，但是发现相应页面表项或目录项中的P（present）标志位为0，则表明相应的物理页面不在内存中，从而无法完成本次内存访问。从理论上说，也许应该把这种情况称为受阻而不是失败，因为映射的关系毕竟已经建立，理应与尚未建立映射的情况有所区别，所以我们称为断开。但是，CPU的MMU硬件并不区分这两种不同的情况，只要P标志位为0就都认为是页面映射失败，CPU就会产生一次页面异常（page fault）。事实上，CPU在映射过程中首先看的就
linux内核分析之缺页中断
bullbat的专栏
12-28 8689
linux缺页异常程序必须能够区分由编程引起的异常以及由引用属于进程地址空间但还尚未分配物理页框的页所引起的异常。在x86-ia32体系上由do_page_fault函数处理，每个版本有所差异，现分析的版本为2.6.32 /* regs:该结构包含当异常发生时的微处理器寄存器的值 3位的error_code,当异常发生时由控制单元压入栈中 -如果第0位被清0，则异常由访问一个不存在
linux 换页进程,linux内存管理之分页机制
weixin_36123285的博客
04-30 462
linux(X86)将进程的地址空间分成一段一段的，利用这些段来存储数据或者代码。x86 硬件包括几个可编程的寄存器，称为 段寄存器 (segment register)，段选择器保存于其中。这些寄存器为 cs(代码段)、ds(数据段)和 ss(堆栈段)。这些寄存器中都存储了段选择符。每个段选择符都是16位。每个段选择符包括：1、一个 13 位的索引，用来标识 GDT 或 LDT 中包含的对应段描...
Linux 存储管理 缺页中断和页面换入
Helping BIOSer become Awesome!
05-10 1203
磁盘中的可执行可执行文件映像（image）一旦初映射到一个进程的虚拟空间，就可以开始执行。由于只有该映像区的开始部分调入内存。因此迟早会执行到那些尚未调入内存的代码。当一个进程访问了一个还没有有效页表项的虚拟地址时（即页表项的P位为0），处理器将产生缺页中断，通知通知操作系统。并将出现缺页的虚拟地址（在CR2寄存器中）和缺页时访问虚存的模式一并传递给Linux的缺页中断服务程序。
linux内存管理-页面的定期换出
guoguangwu的专栏
10-12 631
这个情景比较长，我们得有点耐心。 为了避免总是在CPU忙碌的时候，也就是在缺页异常发生的时候，临时再来搜索可供换出的内存页面并加以换出，linux内核定期地检查并预先将若干页面换出，腾出空间，以减轻系统在缺页异常发生时的负担。当然，由于无法确定地预测页面的使用，即使这样做了也还是不能完全杜绝在缺页异常发生时内存内有空闲页面，而只好临时寻找可换出页面的可能。但是，这样毕竟可以减少其发生的概率。并且，通过选择适当的参数，例如每隔多久换出一次，每次换出多少页面，可以使得在缺页异常发生时必须临时寻找页面换出的情况
Linux缺页统计报错
qq_41612692的博客
01-03 738
这个应该怎么解决啊 求大神！  pf.c的代码： （我尝试过把read_proc改为read_proc_t，一样的报错） /*pf.c*/ #include&lt;linux/init.h&gt; #include&lt;linux/module.h&gt; #include&lt;linux/kernel.h&gt; #include&lt;linux/mm.h&gt; #include&...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值