精华内容
下载资源
问答
  • linux 读写速度测试

    千次阅读 2019-11-01 16:09:26
    测试硬盘/内存的读写速度方法很多,下面介绍...同理of=/dev/null不产生IO,可以用来测试纯读速度。bs是每次读或的大小,即一个块的大小,count是读写块的数量。 测试纯速度 [root@localhost shm]# dd if=/dev/z...

    测试硬盘/内存的读写速度方法很多,下面介绍linux 自带的dd命令测试硬盘的读写速度

    dd用于复制,从if读出,写到of。if=/dev/zero不产生IO,因此可以用来测试纯写速度。同理of=/dev/null不产生IO,可以用来测试纯读速度。bs是每次读或写的大小,即一个块的大小,count是读写块的数量。

    测试纯写速度

    [root@localhost shm]#  dd if=/dev/zero bs=10k  of=/dev/shm/test.b count=100000
    记录了100000+0 的读入
    记录了100000+0 的写出
    1024000000字节(1.0 GB)已复制,0.707544 秒,1.4 GB/秒
    

    测试纯读速度

    [root@localhost shm]# time dd if=/home/test.a  of=/dev/null bs=8k count=10000
    记录了10000+0 的读入
    记录了10000+0 的写出
    81920000字节(82 MB)已复制,0.0346547 秒,2.4 GB/秒
    

    在前面加上time会显示计算复制的时间

    [root@localhost shm]# time dd if=/dev/zero bs=10k  of=/dev/shm/test.b count=100000
    记录了100000+0 的读入
    记录了100000+0 的写出
    1024000000字节(1.0 GB)已复制,0.707544 秒,1.4 GB/秒
    
    real    0m0.737s
    user    0m0.009s
    sys     0m0.727s
    
    • real时间是指挂钟时间,也就是命令开始执行到结束的时间。这个短时间包括其他进程所占用的时间片,和进程被阻塞时所花费的时间。
    • user时间是指进程花费在用户模式中的CPU时间,这是唯一真正用于执行进程所花费的时间,其他进程和花费阻塞状态中的时间没有计算在内。
    • sys时间是指花费在内核模式中的CPU时间,代表在内核中执系统调用所花费的时间,这也是真正由进程使用的CPU时间。

    参数解释:

    • bs:操作块大小
    • count:操作次数,可理解为并发数

    链接:https://blog.csdn.net/gzh0222/article/details/7615050
    https://blog.csdn.net/qq_18941425/article/details/81206484

    展开全文
  • linux系统提升硬盘写速度的方法

    千次阅读 2019-09-26 14:28:49
    LINUX系统写速度问题解决过程 问题描述: linux系统下写速度只有2GB/s左右,无法支持2.5G采样率连续采集,达不到预期的性能。而同样的代码在windows系统下,却可以支持2.5G采样率连续采集,因此这里需要解决Linux...

    LINUX系统写速度问题解决过程

    问题描述:

    linux系统下写速度只有2GB/s左右,无法支持2.5G采样率连续采集,达不到预期的性能。而同样的代码在windows系统下,却可以支持2.5G采样率连续采集,因此这里需要解决Linux系统的写速度问题。

    尝试一:

    刚开始以为是API的问题,查看资料发现大部分说法是mmap写文件最快,实际测试下来发现效果一般,没有特别惊艳的表现。加上使用不太方便,否定了这个解决方案。

    尝试二:

    由于用测速软件测试时两个系统里硬盘的顺序读写速度都是7~8GB/s,所以一开始我在Windows系统下对硬盘做了实际的测试,没有用测速软件,而是纯用writefile函数在写,发现读写在6GB/s左右。而且打开FILE_FLAG_NOBUFFRING标志位后才有这样的速度,不开的话会慢。如图

     

    可以看出写速度约为5GB/s,读速度约为6GB/s。

    然而我换到Linux系统后,也不用测速软件,纯用write函数,发现它的写速度只有2GB/s,但是读速度却在7GB/s。这让我十分怀疑是否是写操作有什么设置没有打开。一番实验查找之后,我发现Windows的raid卡的写策略是启动了写缓存,如图

     

    但是我在Linux系统中却没有找到这样的设置或查询。不过在查看内核打印有一句"Write cache disabled,read cache enabled",如图:

     

    可以看出正好是说写缓存关闭而读缓存打开,跟目前测试出来的情况一致。我一度以为已经找到了问题所在,但是使用hdparm磁盘管理工具却没办法查询或设置raid卡的写缓存

     

    而且这句话是否是描述raid卡的也存疑,在尝试了另外一些设置硬盘写缓存的方法无效后,我放弃了这个解决办法。后来我也确定这句话描述的是另外一个硬盘,而不是我们用的raid卡。

    尝试三:

    于是我又回到了测试速度的工具上。linux下我用测速软件测得磁盘流盘速度为7000M左右。但是我用另一个linux下很常用的dd命令来测速时却和上个软件相差如此之大,如图:

    我想是否是dd命令有一些关于写速度的参数设置,于是仔细研究了dd命令的参数设置后发现:

    这些参数其中direct和nonblock跟我们在windows上采用的“FILE_FLAG_NOBUFFING”,即不使用缓冲区直接操作磁盘的方式相似。于是我对这两个做了测试之后,发现在用dd命令时,加上direct参数,跳过系统缓存,直接写到硬盘,在大量数据连续存储时可以提高性能。查资料后发现direct 模式是把写入请求直接封装成 I/O 指令发到磁盘,非 direct 模式只是把数据写入到系统缓存就认为 I/O 成功,并由操作系统决定缓存中的数据什么时候被写入磁盘。

     

    结论:

    因此我们可以得出这样一个结论,在linux系统中,IO写入的基本过程

    a. 定位用户数据

    b. 将用户数据拷贝至内核中(page cache)

     

    先解释一下page cache。page cache是文件在内存中的缓存,打开文件时,先要把文件加载进pache cache,写入时也是一样,先写入page cache,再由page cache刷入磁盘。一般来说,page cache中的数据也是文件的一部分,所以如果数据写入了page cache,就可以认为io操作已安全完成。

     

    上述的过程是一个非常简化的版本,实际的一些api比如fwrite()的实现可能是这样的

    ---用户层---

    a. 定位用户数据

    b. 将用户数据拷贝至函数的缓存中(函数调用返回)

     

    ---vfs层(即虚拟文件系统)---

    c. 将函数缓存拷贝至内核缓存(page cache) (显式或隐式调用fflush() )

    d. 将page cache中的脏数据写入磁盘数据区(调用硬盘驱动)

    e. 将inode cache中的脏数据写入磁盘inode区(调用硬盘驱动)

     

    ---存储控制器层---

    到目前为止,写入基本完成,数据被存储控制器接管,由于存储控制器自带板载电容,因此可以认为数据已固化

    f. 从板载cache(比如ssd raid 卡)中读取数据

    g. 将数据写入磁盘介质

     

    对于linux的write()函数来说,调用在c步就返回了。而对于fwrite()这种经过一次封装的函数来说,它在write之上增加了一层缓冲,也就是说调用fwrite会在b步返回,为了保证数据写入文件,使用fwrite时,可以调用fflush()函数来保证调用到第c步。如果认为此时存储于操作系统的page cache仍不安全,可以继续调用fsync()来保证调用到第e步。(如果到了这里仍然觉得数据不够安全,可以将存储控制器的模式更改为write through,这样可以保证第g步完成后才返回)。

    如果打开文件时采用了direct io的方式,可以绕开对于page cache的操作,就是绕过了d步,但是,e步并没有被绕过,因此,使用direct io方式时,为了保证数据的绝对安全,依旧需要调用fsync()来保证文件的元数据(inode等信息)写入磁盘(可以在open时增加O_SYNC,但这样会严重影响效率)。

     

    因此对于写文件时要不要缓冲区这个事情,要从具体的应用角度去看。在需要频繁读取写入数据,并且数据的量不是很大时,通过缓存机制可以有效的提升读写数据的速度,因为当你要读取数据时,系统会先查看你要的数据是否在缓存里,如果在缓存中则直接提取,由于数据还没有真正的刷入硬盘中,因此这个操作是电子层面而非IO层面,速度要快的多。当缓存中的数据多到一定程度,系统才会将不常用的数据真正的写入磁盘。

    而这种应用情景,大量数据需要快速的写入硬盘中,全部写完后,用户才有可能会继续回放文件等之类的操作,因此绕开缓存机制,直接以合适的block size循环的写入硬盘,则比用缓存的机制,让系统决定什么时候写入磁盘要快很多。

     

    最后,direct方式是以扇区为单位操作磁盘,因此执行一次写入操作的最小单位是512 Bytes。而且direct方式不常用,在使用时要加一下宏定义_GNU_SOURCE或其他的,否则找不到“O_DIRECT”这个参数,它操作的内存也不能使用平常的定义数组的方式,应该要用mmap或malloc去申请内存,具体使用详情自行百度关键字。

    最终的测试结果如图;

     

    以下为测试源码:
     

    #define _GNU_SOURCE 1
    
    #define __USE_GNU 1
    
    
    
    #include <stdio.h>
    
    #include <assert.h>
    
    #include <fcntl.h>
    
    #include <getopt.h>
    
    #include <stdint.h>
    
    #include <stdio.h>
    
    #include <stdlib.h>
    
    #include <string.h>
    
    #include <unistd.h>
    
    #include <time.h>
    
    
    
    #include <sys/mman.h>
    
    #include <sys/stat.h>
    
    #include <sys/time.h>
    
    #include <sys/types.h>
    
    #include <unistd.h>
    
    
    
    static void *mmap_control(int fd,long mapsize)
    
    {
    
        void *vir_addr;
    
        vir_addr = mmap(NULL, mapsize, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
    
        return vir_addr;
    
    }
    
    
    
    void* pvAllocMemPageAligned (uint64_t qwBytes)
    
        {
    
        void* pvTmp;
    
        int fd = open ("/dev/zero", O_RDONLY);
    
        pvTmp = (void*) mmap (NULL, qwBytes, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0);
    
    
    
        // set everything to zero to get memory allocated in physical mem
    
        if (pvTmp != MAP_FAILED)
    
           memset (pvTmp, 0, qwBytes);
    
        else
    
            pvTmp = NULL;
    
    
    
        close (fd);
    
        return (pvTmp);
    
        }
    
    
    
    // ***********************************************************************
    
    
    
    void vFreeMemPageAligned (void* pvAdr, uint64_t qwBytes)
    
        {
    
        munmap (pvAdr, qwBytes);
    
        }
    
    
    
    static void timespec_sub(struct timespec *t1, const struct timespec *t2);
    
    
    
    int main()
    
    {
    
    printf("CLOCKPERSEC=%ld\n",CLOCKS_PER_SEC);
    
    char filename[64] = "/home/sample/SampleData/testspeed_rcv.bin";
    
    int file_fd = open(filename, O_RDWR | O_CREAT | O_TRUNC|O_DIRECT, 0666);
    
    if(file_fd<0)
    
    {
    
    perror("rcv file err:");
    
    }
    
    
    
    int rc;
    
    int size=2*1024*1024;
    
    //char buffer[4*1024*1024]={0};
    
    void *buffer=NULL;
    
    buffer=pvAllocMemPageAligned(4*1024*1024);
    
    /*void* control_base;
    
    control_base=mmap_control(file_fd,size);
    
    if(control_base=NULL||control_base==(void*) -1)
    
    {
    
    printf("映射失败\n");
    
    close(file_fd);
    
    return -1;
    
    }*/
    
    struct timespec ts_start, ts_end;
    
    clock_gettime(CLOCK_MONOTONIC, &ts_start);
    
    clock_t start1,end1;
    
         start1=clock();
    
    printf("flag1\n");
    
    int times=1000;
    
    for(int i=0;i<times;i++)
    
    {
    
    //memcpy(control_base,buffer,size);
    
    rc= write(file_fd, buffer, size);
    
    if(rc!=size){
    
    perror("write error:");
    
    return -1;
    
    }
    
    }
    
    end1=clock();
    
    printf("flag2\n");
    
    clock_gettime(CLOCK_MONOTONIC, &ts_end);
    
         float dur1=(float)(end1-start1);
    
    printf("Cost Time=%f\n",(dur1/CLOCKS_PER_SEC));
    
    printf("rc=%d\n",rc);
    
    timespec_sub(&ts_end, &ts_start);
    
    printf("Cost %ld.%09ld seconds (total) for transfer \n",
    
         ts_end.tv_sec, ts_end.tv_nsec);
    
    printf("Write Speed=%f\n",(float)(size/1024/1024*times)/(ts_end.tv_sec+ts_end.tv_nsec/1e9));
    
     /*if(munmap(control_base,size)==-1)
    
        {
    
    printf("munmap error!\n");
    
        }*/
    
    close(file_fd);
    
    
    
    file_fd=open(filename,O_RDWR|O_DIRECT);
    
    if(file_fd<0)
    
    {
    
    perror("rcv file err:");
    
    }
    
    start1=clock();
    
    clock_gettime(CLOCK_MONOTONIC, &ts_start);
    
    
    
    for(int i=0;i<times;i++)
    
    {
    
    //memcpy(control_base,buffer,size);
    
    rc= read(file_fd, buffer, size);
    
    if(rc!=size)
    
    {
    
    printf("rc=%d\n",rc);
    
    }
    
    }
    
    
    
    clock_gettime(CLOCK_MONOTONIC, &ts_end);
    
    end1=clock();
    
    dur1=(float)(end1-start1);
    
    printf("\n\nCost Time=%f\n",(dur1/CLOCKS_PER_SEC));
    
    printf("rc=%d\n",rc);
    
    timespec_sub(&ts_end, &ts_start);
    
    printf("Cost %ld.%09ld seconds (total) for transfer \n",
    
         ts_end.tv_sec, ts_end.tv_nsec);
    
    printf("Read Speed=%f\n",(float)(size/1024/1024*times)/(ts_end.tv_sec+ts_end.tv_nsec/1e9));
    
    close(file_fd);
    
    vFreeMemPageAligned(buffer,4*1024*1024);
    
    }
    
    static void timespec_sub(struct timespec *t1, const struct timespec *t2)
    
    {
    
      assert(t1->tv_nsec >= 0);
    
      assert(t1->tv_nsec < 1000000000);
    
      assert(t2->tv_nsec >= 0);
    
      assert(t2->tv_nsec < 1000000000);
    
      t1->tv_sec -= t2->tv_sec;
    
      t1->tv_nsec -= t2->tv_nsec;
    
      if (t1->tv_nsec >= 1000000000)
    
      {
    
        t1->tv_sec++;
    
        t1->tv_nsec -= 1000000000;
    
      }
    
      else if (t1->tv_nsec < 0)
    
      {
    
        t1->tv_sec--;
    
        t1->tv_nsec += 1000000000;
    
      }
    
    }
    
    
    

     

    展开全文
  • Linux内存回收交换

    千次阅读 2019-07-18 08:01:02
    前言Linux的swap相关部分代码从2.6早期版本到现在的4.6版本在细节之处已经有不少变化。本文讨论的swap基于Linux4.4内核代码。Linux内存管理是一套...

    前言

    Linux的swap相关部分代码从2.6早期版本到现在的4.6版本在细节之处已经有不少变化。本文讨论的swap基于Linux 4.4内核代码。Linux内存管理是一套非常复杂的系统,而swap只是其中一个很小的处理逻辑。希望本文能让读者了解Linux对swap的使用大概是什么样子。阅读完本文,应该可以帮你解决以下问题:

    1. swap到底是干嘛的?

    2. swappiness到底是用来调节什么的?

    3. 什么是内存水位标记?

    4. kswapd什么时候会进行swap操作?

    5. swap分区的优先级(priority)有啥用?

    什么是SWAP?

    我们一般所说的swap,指的是一个交换分区或文件。在Linux上可以使用swapon -s命令查看当前系统上正在使用的交换空间有哪些,以及相关信息:

    [zorro@zorrozou-pc0 linux-4.4]$ swapon -s
    Filename                Type        Size    Used    Priority
    /dev/dm-4                                  partition    33554428    0    -1

    从功能上讲,交换分区主要是在内存不够用的时候,将部分内存上的数据交换到swap空间上,以便让系统不会因内存不够用而导致oom或者更致命的情况出现。所以,当内存使用存在压力,开始触发内存回收的行为时,就可能会使用swap空间。内核对swap的使用实际上是跟内存回收行为紧密结合的。那么内存回收和swap的关系,我们可以提出以下几个问题:

    1. 什么时候会进行内存回收呢?

    2. 哪些内存会可能被回收呢?

    3. 回收的过程中什么时候会进行交换呢?

    4. 具体怎么交换?

    下面我们就从这些问题出发,一个一个进行分析。

    内存回收

    内核之所以要进行内存回收,主要原因有两个:

    第一、内核需要为任何时刻突发到来的内存申请提供足够的内存。所以一般情况下保证有足够的free空间对于内核来说是必要的。另外,Linux内核使用cache的策略虽然是不用白不用,内核会使用内存中的page cache对部分文件进行缓存,以便提升文件的读写效率。所以内核有必要设计一个周期性回收内存的机制,以便cache的使用和其他相关内存的使用不至于让系统的剩余内存长期处于很少的状态。

    第二,当真的有大于空闲内存的申请到来的时候,会触发强制内存回收。

    所以,内核在应对这两类回收的需求下,分别实现了两种不同的机制。一个是使用kswapd进程对内存进行周期检查,以保证平常状态下剩余内存尽可能够用。另一个是直接内存回收(direct page reclaim),就是当内存分配时没有空闲内存可以满足要求时,触发直接内存回收。

    这两种内存回收的触发路径不同,一个是由内核进程kswapd直接调用内存回收的逻辑进行内存回收(参见mm/vmscan.c中的kswapd()主逻辑),另一个是内存申请的时候进入slow path的内存申请逻辑进行回收(参见内核代码中的mm/page_alloc.c中的__alloc_pages_slowpath方法)。这两个方法中实际进行内存回收的过程殊途同归,最终都是调用shrink_zone()方法进行针对每个zone的内存页缩减。这个方法中会再调用shrink_lruvec()这个方法对每个组织页的链表进程检查。找到这个线索之后,我们就可以清晰的看到内存回收操作究竟针对的page有哪些了。这些链表主要定义在mm/vmscan.c一个enum中:

    #define LRU_BASE 0
    #define LRU_ACTIVE 1
    #define LRU_FILE 2
    
    enum lru_list {
            LRU_INACTIVE_ANON = LRU_BASE,
            LRU_ACTIVE_ANON = LRU_BASE + LRU_ACTIVE,
            LRU_INACTIVE_FILE = LRU_BASE + LRU_FILE,
            LRU_ACTIVE_FILE = LRU_BASE + LRU_FILE + LRU_ACTIVE,
            LRU_UNEVICTABLE,
            NR_LRU_LISTS
    };

    根据这个enum可以看到,内存回收主要需要进行扫描的包括anon的inactive和active以及file的inactive和active四个链表。就是说,内存回收操作主要针对的就是内存中的文件页(file cache)和匿名页。关于活跃(active)还是不活跃(inactive)的判断内核会使用lru算法进行处理并进行标记,我们这里不详细解释这个过程。

    整个扫描的过程分几个循环,首先扫描每个zone上的cgroup组。然后再以cgroup的内存为单元进行page链表的扫描。内核会先扫描anon的active链表,将不频繁的放进inactive链表中,然后扫描inactive链表,将里面活跃的移回active中。进行swap的时候,先对inactive的页进行换出。如果是file的文件映射page页,则判断其是否为脏数据,如果是脏数据就写回,不是脏数据可以直接释放。

    这样看来,内存回收这个行为会对两种内存的使用进行回收,一种是anon的匿名页内存,主要回收手段是swap,另一种是file-backed的文件映射页,主要的释放手段是写回和清空。因为针对file based的内存,没必要进行交换,其数据原本就在硬盘上,回收这部分内存只要在有脏数据时写回,并清空内存就可以了,以后有需要再从对应的文件读回来。内存对匿名页和文件缓存一共用了四条链表进行组织,回收过程主要是针对这四条链表进行扫描和操作。

    swappiness的作用究竟是什么?

    我们应该都知道/proc/sys/vm/swappiness这个文件,是个可以用来调整跟swap相关的参数。这个文件的默认值是60,可以的取值范围是0-100。这很容易给大家一个暗示:我是个百分比哦!那么这个文件具体到底代表什么意思呢?我们先来看一下说明:

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

    swappiness

    This control is used to define how aggressive the kernel will swapmemory pages.  Higher values will increase agressiveness, lower valuesdecrease the amount of swap.  A value of 0 instructs the kernel not toinitiate swap until the amount of free and file-backed pages is lessthan the high water mark in a zone.

    The default value is 60.

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

    这个文件的值用来定义内核使用swap的积极程度。值越高,内核就会越积极的使用swap,值越低就会降低对swap的使用积极性。如果这个值为0,那么内存在free和file-backed使用的页面总量小于高水位标记(high water mark)之前,不会发生交换。

    在这里我们可以理解file-backed这个词的含义了,实际上就是上文所说的文件映射页的大小。那么这个swappiness到底起到了什么作用呢?我们换个思路考虑这个事情。假设让我们设计一个内存回收机制,要去考虑将一部分内存写到swap分区上,将一部分file-backed的内存写回并清空,剩余部分内存出来,我们将怎么设计?

    我想应该主要考虑这样几个问题。

    1. 如果回收内存可以有两种途径(匿名页交换和file缓存清空),那么我应该考虑在本次回收的时候,什么情况下多进行file写回,什么情况下应该多进行swap交换。说白了就是平衡两种回收手段的使用,以达到最优。

    2. 如果符合交换条件的内存较长,是不是可以不用全部交换出去?比如可以交换的内存有100M,但是目前只需要50M内存,实际只要交换50M就可以了,不用把能交换的都交换出去。

    分析代码会发现,Linux内核对这部分逻辑的实现代码在get_scan_count()这个方法中,这个方法被shrink_lruvec()调用。get_sacn_count()就是处理上述逻辑的,swappiness是它所需要的一个参数,这个参数实际上是指导内核在清空内存的时候,是更倾向于清空file-backed内存还是更倾向于进行匿名页的交换的。当然,这只是个倾向性,是指在两个都够用的情况下,更愿意用哪个,如果不够用了,那么该交换还是要交换。

    简单看一下get_sacn_count()函数的处理部分代码,其中关于swappiness的第一个处理是:

        /*
         * With swappiness at 100, anonymous and file have the same priority.
         * This scanning priority is essentially the inverse of IO cost.
         */
        anon_prio = swappiness;
        file_prio = 200 - anon_prio;

    这里注释的很清楚,如果swappiness设置为100,那么匿名页和文件将用同样的优先级进行回收。很明显,使用清空文件的方式将有利于减轻内存回收时可能造成的IO压力。因为如果file-backed中的数据不是脏数据的话,那么可以不用写回,这样就没有IO发生,而一旦进行交换,就一定会造成IO。所以系统默认将swappiness的值设置为60,这样回收内存时,对file-backed的文件cache内存的清空比例会更大,内核将会更倾向于进行缓存清空而不是交换。

    这里的swappiness值如果是60,那么是不是说内核回收的时候,会按照60:140的比例去做相应的swap和清空file-backed的空间呢?并不是。在做这个比例计算的时候,内核还要参考当前内存使用的其他信息。对这里具体是怎么处理感兴趣的人,可以自己详细看get_sacn_count()的实现,本文就不多解释了。我们在此要明确的概念是:swappiness的值是用来控制内存回收时,回收的匿名页更多一些还是回收的file cache更多一些

    那么swappiness设置为0的话,是不是内核就根本不会进行swap了呢?这个答案也是否定的。首先是内存真的不够用的时候,该swap的话还是要swap。其次在内核中还有一个逻辑会导致直接使用swap,内核代码是这样处理的:

        /*
         * Prevent the reclaimer from falling into the cache trap: as
         * cache pages start out inactive, every cache fault will tip
         * the scan balance towards the file LRU.  And as the file LRU
         * shrinks, so does the window for rotation from references.
         * This means we have a runaway feedback loop where a tiny
         * thrashing file LRU becomes infinitely more attractive than
         * anon pages.  Try to detect this based on file LRU size.
         */
        if (global_reclaim(sc)) {
                unsigned long zonefile;
                unsigned long zonefree;
    
                zonefree = zone_page_state(zone, NR_FREE_PAGES);
                zonefile = zone_page_state(zone, NR_ACTIVE_FILE) +
                           zone_page_state(zone, NR_INACTIVE_FILE);
    
                if (unlikely(zonefile + zonefree &lt;= high_wmark_pages(zone))) {
                        scan_balance = SCAN_ANON;
                        goto out;
                }
        }

    这里的逻辑是说,如果触发的是全局回收,并且zonefile + zonefree <= high_wmark_pages(zone)条件成立时,就将scan_balance这个标记置为SCAN_ANON。后续处理scan_balance的时候,如果它的值是SCAN_ANON,则一定会进行针对匿名页的swap操作。要理解这个行为,我们首先要搞清楚什么是高水位标记(high_wmark_pages)。

    内存水位标记(watermark)

    我们回到kswapd周期检查和直接内存回收的两种内存回收机制。直接内存回收比较好理解,当申请的内存大于剩余内存的时候,就会触发直接回收。那么kswapd进程在周期检查的时候触发回收的条件是什么呢?还是从设计角度来看,kswapd进程要周期对内存进行检测,达到一定阈值的时候开始进行内存回收。这个所谓的阈值可以理解为内存目前的使用压力,就是说,虽然我们还有剩余内存,但是当剩余内存比较小的时候,就是内存压力较大的时候,就应该开始试图回收些内存了,这样才能保证系统尽可能的有足够的内存给突发的内存申请所使用。

    那么如何描述内存使用的压力呢?Linux内核使用水位标记(watermark)的概念来描述这个压力情况。Linux为内存的使用设置了三种内存水位标记,high、low、min。他们所标记的分别含义为:剩余内存在high以上表示内存剩余较多,目前内存使用压力不大;high-low的范围表示目前剩余内存存在一定压力;low-min表示内存开始有较大使用压力,剩余内存不多了;min是最小的水位标记,当剩余内存达到这个状态时,就说明内存面临很大压力。小于min这部分内存,内核是保留给特定情况下使用的,一般不会分配。内存回收行为就是基于剩余内存的水位标记进行决策的,当系统剩余内存低于watermark[low]的时候,内核的kswapd开始起作用,进行内存回收。直到剩余内存达到watermark[high]的时候停止。如果内存消耗导致剩余内存达到了或超过了watermark[min]时,就会触发直接回收(direct reclaim)。

    明白了水位标记的概念之后,zonefile + zonefree <= high_wmark_pages(zone)这个公式就能理解了。这里的zonefile相当于内存中文件映射的总量,zonefree相当于剩余内存的总量。内核一般认为,如果zonefile还有的话,就可以尽量通过清空文件缓存获得部分内存,而不必只使用swap方式对anon的内存进行交换。整个判断的概念是说,在全局回收的状态下(有global_reclaim(sc)标记),如果当前的文件映射内存总量+剩余内存总量的值评估小于等于watermark[high]标记的时候,就可以进行直接swap了。这样是为了防止进入cache陷阱,具体描述可以见代码注释。这个判断对系统的影响是,swappiness设置为0时,有剩余内存的情况下也可能发生交换。

    那么watermark相关值是如何计算的呢?所有的内存watermark标记都是根据当前内存总大小和一个可调参数进行运算得来的,这个参数是:/proc/sys/vm/min_free_kbytes。首先这个参数本身决定了系统中每个zone的watermark[min]的值大小,然后内核根据min的大小并参考每个zone的内存大小分别算出每个zone的low水位和high水位值。想了解具体逻辑可以参见源代码目录下的:mm/page_alloc.c文件。在系统中可以从/proc/zoneinfo文件中查看当前系统的相关的信息和使用情况。

    我们会发现以上内存管理的相关逻辑都是以zone为单位的,这里zone的含义是指内存的分区管理。Linux将内存分成多个区,主要有直接访问区(DMA)、一般区(Normal)和高端内存区(HighMemory)。内核对内存不同区域的访问因为硬件结构因素会有寻址和效率上的差别。如果在NUMA架构上,不同CPU所管理的内存也是不同的zone。

    相关参数设置

    zone_reclaim_mode

    zone_reclaim_mode模式是在2.6版本后期开始加入内核的一种模式,可以用来管理当一个内存区域(zone)内部的内存耗尽时,是从其内部进行内存回收还是可以从其他zone进行回收的选项,我们可以通过/proc/sys/vm/zone_reclaim_mode文件对这个参数进行调整。

    在申请内存时(内核的get_page_from_freelist()方法中),内核在当前zone内没有足够内存可用的情况下,会根据zone_reclaim_mode的设置来决策是从下一个zone找空闲内存还是在zone内部进行回收。这个值为0时表示可以从下一个zone找可用内存,非0表示在本地回收。这个文件可以设置的值及其含义如下:

    1. echo 0 > /proc/sys/vm/zone_reclaim_mode:意味着关闭zone_reclaim模式,可以从其他zone或NUMA节点回收内存。

    2. echo 1 > /proc/sys/vm/zone_reclaim_mode:表示打开zone_reclaim模式,这样内存回收只会发生在本地节点内。

    3. echo 2 > /proc/sys/vm/zone_reclaim_mode:在本地回收内存时,可以将cache中的脏数据写回硬盘,以回收内存。

    4. echo 4 > /proc/sys/vm/zone_reclaim_mode:可以用swap方式回收内存。

    不同的参数配置会在NUMA环境中对其他内存节点的内存使用产生不同的影响,大家可以根据自己的情况进行设置以优化你的应用。默认情况下,zone_reclaim模式是关闭的。这在很多应用场景下可以提高效率,比如文件服务器,或者依赖内存中cache比较多的应用场景。这样的场景对内存cache速度的依赖要高于进程进程本身对内存速度的依赖,所以我们宁可让内存从其他zone申请使用,也不愿意清本地cache。

    如果确定应用场景是内存需求大于缓存,而且尽量要避免内存访问跨越NUMA节点造成的性能下降的话,则可以打开zone_reclaim模式。此时页分配器会优先回收容易回收的可回收内存(主要是当前不用的page cache页),然后再回收其他内存。

    打开本地回收模式的写回可能会引发其他内存节点上的大量的脏数据写回处理。如果一个内存zone已经满了,那么脏数据的写回也会导致进程处理速度收到影响,产生处理瓶颈。这会降低某个内存节点相关的进程的性能,因为进程不再能够使用其他节点上的内存。但是会增加节点之间的隔离性,其他节点的相关进程运行将不会因为另一个节点上的内存回收导致性能下降。

    除非针对本地节点的内存限制策略或者cpuset配置有变化,对swap的限制会有效约束交换只发生在本地内存节点所管理的区域上。

    min_unmapped_ratio

    这个参数只在NUMA架构的内核上生效。这个值表示NUMA上每个内存区域的pages总数的百分比。在zone_reclaim_mode模式下,只有当相关区域的内存使用达到这个百分比,才会发生区域内存回收。在zone_reclaim_mode设置为4的时候,内核会比较所有的file-backed和匿名映射页,包括swapcache占用的页以及tmpfs文件的总内存使用是否超过这个百分比。其他设置的情况下,只比较基于一般文件的未映射页,不考虑其他相关页。

    page-cluster

    page-cluster是用来控制从swap空间换入数据的时候,一次连续读取的页数,这相当于对交换空间的预读。这里的连续是指在swap空间上的连续,而不是在内存地址上的连续。因为swap空间一般是在硬盘上,对硬盘设备的连续读取将减少磁头的寻址,提高读取效率。这个文件中设置的值是2的指数。就是说,如果设置为0,预读的swap页数是2的0次方,等于1页。如果设置为3,就是2的3次方,等于8页。同时,设置为0也意味着关闭预读功能。文件默认值为3。我们可以根据我们的系统负载状态来设置预读的页数大小。

    swap的相关操纵命令

    可以使用mkswap将一个分区或者文件创建成swap空间。swapon可以查看当前的swap空间和启用一个swap分区或者文件。swapoff可以关闭swap空间。我们使用一个文件的例子来演示一下整个操作过程:

    制作swap文件:

    [root@zorrozou-pc0 ~]# dd if=/dev/zero of=./swapfile bs=1M count=8G
    dd: error writing './swapfile': No space left on device
    14062+0 records in
    14061+0 records out
    14744477696 bytes (15 GB, 14 GiB) copied, 44.0824 s, 334 MB/s
    [root@zorrozou-pc0 ~]# mkswap swapfile
    mkswap: swapfile: insecure permissions 0644, 0600 suggested.
    Setting up swapspace version 1, size = 13.7 GiB (14744473600 bytes)
    no label, UUID=a0ac2a67-0f68-4189-939f-4801bec7e8e1

    启用swap文件:

    [root@zorrozou-pc0 ~]# swapon swapfile
    swapon: /root/swapfile: insecure permissions 0644, 0600 suggested.
    [root@zorrozou-pc0 ~]# swapon -s
    Filename                Type        Size    Used    Priority
    /dev/dm-4                                  partition    33554428    9116    -1
    /root/swapfile                             file        14398900    0    -2

    关闭swap空间:

    [root@zorrozou-pc0 ~]# swapoff /root/swapfile
    [root@zorrozou-pc0 ~]# swapon -s
    Filename                Type        Size    Used    Priority
    /dev/dm-4                                  partition    33554428    9116    -1

    在使用多个swap分区或者文件的时候,还有一个优先级的概念(Priority)。在swapon的时候,我们可以使用-p参数指定相关swap空间的优先级,值越大优先级越高,可以指定的数字范围是-1到32767。内核在使用swap空间的时候总是先使用优先级高的空间,后使用优先级低的。当然如果把多个swap空间的优先级设置成一样的,那么两个swap空间将会以轮询方式并行进行使用。如果两个swap放在两个不同的硬盘上,相同的优先级可以起到类似RAID0的效果,增大swap的读写效率。另外,编程时使用mlock()也可以将指定的内存标记为不会换出,具体帮助可以参考man 2 mlock。

    最后

    关于swap的使用建议,针对不同负载状态的系统是不一样的。有时我们希望swap大一些,可以在内存不够用的时候不至于触发oom-killer导致某些关键进程被杀掉,比如数据库业务。也有时候我们希望不要swap,因为当大量进程爆发增长导致内存爆掉之后,会因为swap导致IO跑死,整个系统都卡住,无法登录,无法处理。这时候我们就希望不要swap,即使出现oom-killer也造成不了太大影响,但是不能允许服务器因为IO卡死像多米诺骨牌一样全部死机,而且无法登陆。跑cpu运算的无状态的apache就是类似这样的进程池架构的程序。

    所以,swap到底怎么用?要还是不要?设置大还是小?相关参数应该如何配置?是要根据我们自己的生产环境的情况而定的。阅读完本文后希望大家可以明白一些swap的深层次知识。我简单总结一下:

    1. 一个内存剩余还比较大的系统中,是否有可能使用swap?有可能,如果运行中的某个阶段出发了这个条件:zonefile + zonefree <= high_wmark_pages(zone),就可能会swap。

    2. swappiness设置为0就相当于关闭swap么?不是的,关闭swap要使用swapoff命令。swappiness只是在内存发生回收操作的时候用来平衡cache回收和swap交换的一个参数,调整为0意味着,尽量通过清缓存来回收内存。

    3. swappiness设置为100代表系统会尽量少用剩余内存而多使用swap么?不是的,这个值设置为100表示内存发生回收时,从cache回收内存和swap交换的优先级一样。就是说,如果目前需求100M内存,那么较大机率会从cache中清除50M内存,再将匿名页换出50M,把回收到的内存给应用程序使用。但是这还要看cache中是否能有空间,以及swap是否可以交换50m。内核只是试图对它们平衡一些而已。

    4. kswapd进程什么时候开始内存回收?kswapd根据内存水位标记决定是否开始回收内存,如果标记达到low就开始回收,回收到剩余内存达到high标记为止。

    5. 如何查看当前系统的内存水位标记?cat /proc/zoneinfo。

    640?wx_fmt=png

    添加极客助手微信,加入技术交流群

    640?wx_fmt=png

    640?wx_fmt=jpeg

    长按,扫码,关注公众号

    点赞、留言、转发!

    展开全文
  • 入门学习Linux常用必会60个命令实例详解doc/txt

    千次下载 热门讨论 2011-06-09 00:08:45
    这是因为Linux和许多版本的Unix一样,提供了虚拟控制台的访问方式,允许用户在同一时间从控制台(系统的控制台是与系统直接相连的监视器键盘)进行多次登录。每个虚拟控制台可以看作是一个独立的工作站,工作台...
  • documentlinux内存机制CPU内存虚拟内存硬盘物理内存内存虚拟内存跟 Windows 完全不同的 Linux 内存机制Swap配置对性能的影响 linux内存机制 Linux支持虚拟内存(Virtual Mmemory),虚拟内存是指使用磁盘当作RAM的...

    本文有些篇幅较长,但如果认真读下来,相信你会收获颇丰!!


    在这里插入图片描述

    linux内存机制

    Linux支持虚拟内存(Virtual Mmemory),虚拟内存是指使用磁盘当作RAM的扩展,这样可用的内存的大小就相应地增大了。内核会将暂时不用的内存块的内容写到硬盘上,这样一来,这块内存就可用于其它目的。当需要用到原始的内容时,它们被重新读入内存。这些操作对用户来说是完全透明的;Linux下运行的程序只是看到有大量的内存可供使用而并没有注意到时不时它们的一部分是驻留在硬盘上的。当然,读写硬盘要比直接使用真实内存慢得多(要慢数千倍),所以程序就不会象一直在内存中运行的那样快。用作虚拟内存的硬盘部分被称为交换空间(Swap Space)

    一般,在交换空间中的页面首先被换入内存;如果此时没有足够的物理内存来容纳它们又将被交换出来(到其他的交换空间中)。如果没有足够的虚拟内存来容纳所有这些页面,Linux就会波动而不正常;但经过一段较长的时间Linux会恢复,但此时系统已不可用了。

    有时,尽管有许多的空闲内存,仍然会有许多的交换空间正被使用。这种情况是有可能发生的,例如如果在某一时刻有进行交换的必要,但后来一个占用很多物理内存的大进程结束并释放内存时。被交换出的数据并不会自动地交换进内存,除非有这个需要时。此时物理内存会在一段时间内保持空闲状态。对此并没有什么可担心的,但是知道了是怎么一回事,也就无所谓了。许多操作系统使用了虚拟内存的方法。因为它们仅在运行时才需要交换空间,以解决不会在同一时间使用交换空间,因此,除了当前正在运行的操作系统的交换空间,其它的就是一种浪费。所以让它们共享一个交换空间将会更有效率。

    注意:如果会有几个人同时使用这个系统,他们都将消耗内存。然而,如果两个人同时运行一个程序,内存消耗的总量并不是翻倍,因为代码页以及共享的库只存在一份。Linux系统常常动不动就使用交换空间,以保持尽可能多的空闲物理内存。即使并没有什么事情需要内存,Linux也会交换出暂时不用的内存页面。这可以避免等待交换所需的时间:当磁盘闲着,就可以提前做好交换。可以将交换空间分散在几个硬盘之上。针对相关磁盘的速度以及对磁盘的访问模式,这样做可以提高性能。与访问物理内存相比,磁盘的读写是很慢的。另外,在相应较短的时间内多次读磁盘同样的部分也是常有的事。例如,某人也许首先阅读了一段E-mail消息,然后为了答复又将这段消息读入编辑器中,然后又在将这个消息拷贝到文件夹中时,使得邮件程序又一次读入它。或者考虑一下在一个有着许多用户的系统中 ls命令会被使用多少次。通过将信息从磁盘上仅读入一次并将其存于内存中,除了第一次读以外,可以加快所有其它读的速度。这叫作磁盘缓冲(Disk Buffering),被用作此目的的内存称为高速缓冲(Buffer Cache)。但是,由于内存是一种有限而又不充足的资源,高速缓冲不可能做的很大(它不可能包容要用到的所有数据)。当缓冲充满了数据时,其中最长时间不用的数据将被舍弃以腾出内存空间用于新的数据。对写磁盘操作来说磁盘缓冲技术同样有效。一方面,被写入磁盘的数据常常会很快地又被读出(例如,原代码文件被保存到一个文件中,又被编译器读入),所以将要被写的数据放入缓冲中是个好主意。另一方面,通过将数据放入缓冲中,而不是将其立刻写入磁盘,程序可以加快运行的速度。以后,写的操作可以在后台完成,而不会拖延程序的执行。

    大多数操作系统都有高速缓冲(尽管可能称呼不同),但是并不是都遵守上面的原理。有些是直接写(Write-Through):数据将被立刻写入磁盘(当然,数据也被放入缓存中)。如果写操作是在以后做的,那么该缓存被称为后台写(Write-Back)。后台写比直接写更有效,但也容易出错:如果机器崩溃,或者突然掉电,缓冲中改变过的数据就被丢失了。如果仍未被写入的数据含有重要的薄记信息,这甚至可能意味着文件系统(如果有的话)已不完整。
    针对以上的原因,出现了很多的日志文件系统,数据在缓冲区修改后,同时会被文件系统记录修改信息,这样即使此时系统掉电,系统重启后会首先从日志记录中恢复数据,保证数据不丢失。当然这些问题不再本文的叙述范围。由于上述原因,在使用适当的关闭过程之前,绝对不要关掉电源,Sync命令倾空(Flushes)缓冲,也即,强迫所有未被写的数据写入磁盘,可用以确定所有的写操作都已完成。在传统的UNIX系统中,有一个叫做update的程序运行于后台,每隔30秒做一次sync操作,因此通常无需手工使用sync命令了。Linux另外有一个后台程序,Bdflush,这个程序执行更频繁的但不是全面的同步操作,以避免有时sync的大量磁盘I/O操作所带来的磁盘的突然冻结。在Linux中,Bdflush是由update启动的。通常没有理由来担心此事,但如果由于某些原因bdflush进程死掉了,内核会对此作出警告,此时你就要手工地启动它了(/sbin/update)。

    **缓存(Cache)**实际并不是缓冲文件的,而是缓冲块的,块是磁盘I/O操作的最小单元(在Linux中,它们通常是1KB)。这样,目录、超级块、其它文件系统的薄记数据以及非文件系统的磁盘数据都可以被缓冲了。缓冲的效力主要是由它的大小决定的。缓冲太小的话等于没用。它只能容纳一点数据,因此在被重用时,所有缓冲的数据都将被倾空。实际的大小依赖于数据读写的频次、相同数据被访问的频率。只有用实验的方法才能知道。如果缓存有固定的大小,那么缓存太大了也不好,因为这会使得空闲的内存太小而导致进行交换操作(这同样是慢的)。为了最有效地使用实际内存,Linux自动地使用所有空闲的内存作为高速缓冲,当程序需要更多的内存时,它也会自动地减小缓冲的大小。这就是一般情况下Linux内存的一般机制,真正的Linux内存的运行机制远远比这个复杂

    CPU

    CPU即中央处理器,是英语“Central Processing Unit”的缩写。CPU从内存或
    缓存中取出指令,放入指令寄存器,并对指令译码分解成一系列的微操作,然后发出各种控制命令,执行微操作系列,从而完成一条指令的执行。

    内存

    但是,CPU并不能直接调用存储在硬盘上的系统、程序和数据,必须首先将硬盘的有关内容存储在内存中,这样才能被CPU读取运行。因而,内存(即物理内存,是相对于硬盘这个“外存”而言)作为硬盘和CPU的“中转站”,对电脑运行速度有较大影响。

    虚拟内存

    当运行数据超出物理内存容纳限度的时候,部分数据就会自行“溢出”,这时系统就会将硬盘上的部分空间模拟成内存——虚拟内存,并将暂时不运行的程序或不使用的数据存放到这部分空间之中,等待需要的时候方便及时调用。

    硬盘

    由于内存是带电存储的(一旦断电数据就会消失),而且容量有限,所以要长时间储存程序或数据就需要使用硬盘(外存储器)。硬盘也会影响系统速度,因为系统从硬盘中读取数据并通过总线存入内存的速度也会影响系统运行的快慢

    物理内存

    物理内存是真正的内存,在应用中顾名思义,物理上,真实的插在板子上的内存是多大就是多大了。看机器配置的时候,看的就是这个物理内存。虚拟内存是为了满足系统对超出物理内存容量的需求时在外存(如硬盘)上开辟的存储空间。由于虚拟内存其实是放在外存上,因而与物理内存相比读写速度都非常慢

    内存和虚拟内存

    内存在计算机中的作用很大,电脑中所有运行的程序都需要经过内存来执行,如果执行的程序很大或很多,就会导致内存消耗更大。为了解决这个问题,可以使用虚拟内存技术,即拿出一部分硬盘空间来充当内存使用,当内存占用完时,电脑就会自动调用硬盘来充当内存,以缓解内存的紧张。比如说当电脑要读取一个比物理内存还要大的文件时,就要用到虚拟内存,文件被内存读取之后就会先储存到虚拟内存,等待内存把文件全部储存到虚拟内存之后,就把虚拟内里储存的文件释放到原来的目录里了。

    跟 Windows 完全不同的 Linux 内存机制

    在 Linux 中经常发现空闲内存很少,似乎所有的内存都被系统占用了,表面感觉是内存不够用了,其实不然。这是 Linux 内存管理的一个优秀特性,在这方面,区别于 Windows 的内存管理。主要特点是,无论物理内存有多大,Linux 都将其充份利用,将一些程序调用过的硬盘数据读入内存,利用内存读写的高速特性来提高 Linux 系统的数据访问性能。而 Windows 是只在需要内存时,才为应用程序分配内存,并不能充分利用大容量的内存空间。换句话说,每增加一些物理内存,Linux 都将能充分利用起来,发挥了硬件投资带来的好处,而 Windows 只将其做为摆设,即使增加 8GB 甚至更大。
    在这里插入图片描述

    Linux 的这一特性,主要是利用空闲的物理内存,划分出一部份空间,做为 cache 和 buffers ,以此提高数据访问性能。

    页高速缓存(cache)是 Linux内核实现的一种主要磁盘缓存。它主要用来减少对磁盘的I/O操作。具体地讲,是通过把磁盘中的数据缓存到物理内存中,把对磁盘的访问变为对物理 内存的访问。

    磁盘高速缓存的价值在于两个方面:

    1. 访问磁盘的速度要远远低于访问内存的速度,因此,从内存访问数据比从磁盘访问速度更快;
    2. 数据一旦被访 问,就很有可能在短期内再次被访问到。

    综上所述,一般不需要太关注Linux的内存占用情况,如果SWAP占用率很高的话一般可能就是内存不够用了。

    Swap配置对性能的影响

    分配太多的Swap空间会浪费磁盘空间,而Swap空间太少,则系统会发生错误。如果系统的物理内存用光了,系统就会跑得很慢,但仍能运行;如果Swap空间用光了,那么系统就会发生错误。例如,Web服务器能根据不同的请求数量衍生出多个服务进程(或线程),如果Swap空间用完,则服务进程无法启动,通常会出现“application is out of memory”的错误,严重时会造成服务进程的死锁。因此Swap空间的分配是很重要的。

    通常情况下,Swap空间应大于或等于物理内存的大小,最小不应小于64M,通常Swap空间的大小应是物理内存的2-2.5倍。但根据不同的应用,应有不同的配置:如果是小的桌面系统,则只需要较小的Swap空间,而大的服务器系统则视情况不同需要不同大小的Swap空间。特别是数据库服务器和Web服务器,随着访问量的增加,对Swap空间的要求也会增加,一般来说对于4G以下的物理内存,配置2倍的swap,4G以上配置1倍。

    另外,Swap分区的数量对性能也有很大的影响。因为Swap交换的操作是磁盘IO的操作,如果有多个Swap交换区,Swap空间的分配会以轮流的方式操作于所有的Swap,这样会大大均衡IO的负载,加快Swap交换的速度。如果只有一个交换区,所有的交换操作会使交换区变得很忙,使系统大多数时间处于等待状态,效率很低。用性能监视工具就会发现,此时的CPU并不很忙,而系统却慢。这说明,瓶颈在IO上,依靠提高CPU的速度是解决不了问题的。

    展开全文
  • linux下测试磁盘的读写IO速度

    千次阅读 2016-08-04 17:23:02
    有时候我们在做维护的时候,总会遇到类似于IO特别高,但不能判定是IO瓶颈还是软件...这是一个是用来获取ATA/IDE硬盘的参数的命令,是由早期Linux IDE驱动的开发维护人员 Mark Lord开发编写的( hdparm has been writte
  • dd命令测试linux磁盘读写速度操作

    千次阅读 2018-10-18 12:31:13
    1、先熟悉两个特殊的设备: ...2、测试磁盘能力  time dd if=/dev/zero of=/testw.dbf bs=4k count=100000  rm -f /testw.dbf  因为/dev//zero是一个伪设备,它只产生空字符流,对它不会产生IO,所以,IO都...
  • Linux 测试 IO 性能(磁盘读写速度

    万次阅读 2018-01-10 13:54:39
    Linux 测试 IO 性能(磁盘读写速度) 这几天做MySQL性能测试,偌大一个公司,找几台性能测试机器都很纠结,终于协调到两台,IO的性能如何还不知道。 数据库属于IO密集型的应用,所以还是先评估下Server的IO...
  • Linux总结

    千次阅读 多人点赞 2020-01-14 20:36:45
    二 、初探Linux 2.1 Linux简介 2.2 Linux诞生简介 2.3 Linux的分类 三 、Linux文件系统概览 3.1 Linux文件系统简介 3.2 文件类型与目录结构 四 、Linux基本命令 4.1 目录切换命令 4.2 目录的操作命令(增删改...
  • Linux初学者面试问题 Linux基本面试问题 ...这是一个用户友好的环境,他们可以在其中轻松修改创建源代码的变体。 2.谁发明了Linux?解释Linux的历史? 回答:Linus Torvalds创建了Linux。莱纳斯·...
  • Linux C++内存映射方式读写文件

    千次阅读 2017-01-16 16:44:05
    内存映射就是将磁盘上的文件映射到系统内存中,对内存的修改可以同步到对磁盘文件的修改。可以对大数据文件处理,并且可以提高文件的读写速度。 1 2 3 4 5 6 7 8 9 ...
  • Linux 命令面试题

    万次阅读 多人点赞 2019-07-24 09:40:04
    Linux面试题: 1.Linux常用系统安全命令 sudo // 超级用户 su // 用于切换当前用户身份到其他身份,变更时需输入所要变更的用户账号与密码。 chmod // 用来变更文件或目录的权限 setfacl // 设置文件访问控制列表 2....
  • 查看linux内存和硬盘

    千次阅读 2018-05-24 10:56:11
    total:表示物理 内存总量 used:表示总计分配给缓存(包含buffers 与cache )使用的数量,但其中可能部分缓存并未实际使用 free:未被分配的内存 shared:共享内存 buffers:系统分配但未被使用的buffers 数量...
  • 数据库属于IO密集型的应用,所以还是先评估下Server的IO性能,看看是否能线上的机器匹配上。 之前一直知道用dd(device to device)命令可以简单测试磁盘的IO读写速度,但没有深究。 但这次做性能测试的关系,...
  • linux挂载u盘并测试读写速度

    千次阅读 2019-05-10 14:17:29
     在这个命令下,一个是物理分区,一个是实际的文件,对它们的读写都会产生IO(对/dev/sdb是,对/testrw.dbf是),假设它们都在一个磁盘中,这个命令就相当于测试磁盘的同时读写能力。  
  • Linux内存CacheBuffer理解

    万次阅读 多人点赞 2018-09-02 11:24:03
    Linux 系统中,我们经常用 free 命令来查看系统内存的使用状态。在一个 RHEL6 的系统上,free 命令的显示内容大概是这样一个状态:   [root@tencent64 ~]# free total used free shared buffers cached ...
  • dd命令测试linux磁盘读写速度

    千次阅读 2019-06-20 12:50:42
    dd命令测试linux磁盘读写速度 1、先熟悉两个特殊的设备: (1)/dev/null:回收站、无底洞。 (2)/dev/zero:产生字符。 2、测试磁盘能力 time dd if=/dev/zero of=/testw.dbf bs=4k count=100000 因为/dev/...
  • 之前一直知道用dd(device to device)命令可以简单测试磁盘的IO读写速度,但没有深究。 但这次做性能测试的关系,需要得到一个相对精确的值(之前的测试吃过这方面的亏,插个题外话,性能测试一定要首先确认好测试...
  • linux内存机制整理

    千次阅读 2018-04-18 19:31:51
    这是Linux内存管理的一个优秀特性,在这方 面,区别于Windows的内存管理。主要特点是,无论物理内存有多大,Linux 都将其充份利用,将一些程序调用过的硬盘数据读入内存,利用内存读写的高速特性来提高Linux系统的...
  • Linux内存管理机制(最透彻的一篇)

    万次阅读 多人点赞 2018-08-05 14:10:09
    在本章最后,我们给出一个内存映射的实例,帮助网友们理解内核内存管理与用户内存管理之间的关系,希望大家最终能驾驭Linux内存管理。 前言 内存管理一向是所有操作系统书籍不惜笔墨重点讨论的内容,无论市...
  • Linux内存管理(最透彻的一篇)

    万次阅读 多人点赞 2019-05-16 14:27:22
    【转】Linux内存管理(最透彻的一篇) 摘要:本章首先以应用程序开发者的角度审视Linux的进程内存管理,在此基础上逐步深入到内核中讨论系统物理内存管理内核内存的使用方法。力求从外到内、水到渠成地引导网友...
  • 在某些情况下,我们想知道NAND Flash的大概读写速度,这些情况可能包括: 1.打算更换一颗型号不同但存储类型、存储容量、页大小都相同的NAND 2.打算更换一颗存储类型不同的NAND,例如从SLC NAND FLASH更换成MLC ...
  • 3、该内存库只允许一个模块写入, 但可多个模块读取, 但需要各个读取模块没有任何相互干扰, 比如一个模块可能读取的速度较慢, 一个读取的速度较快 4、该内存库需要具有一定的数据缓冲, 实际的应用上, ...
  • 还需要在嵌入式环境中实际测试下才准确,linux下命令dd使用指定的输入输出块大小来拷贝文件,它每次从输入读取指定大小的一个块到独立的输出块去,通过这种方法来测试读写速度。 测试环境 硬件:嵌入式ARM ...
  • linux内存管理原理深入理解段式页式

    万次阅读 多人点赞 2017-07-20 08:52:39
    前一段时间看了《深入理解Linux内核》对其中的内存管理部分花了不少时间,但是还是有很多问题不是很清楚,最近又花了一些时间复习了一下,在这里记录下自己的理解Linux内存管理的一些看法认识。  我比较...
  • linux内存实际占用分析

    千次阅读 2018-07-27 18:07:23
    ”导致大多数人认为许多Linux应用程序,特别是KDE或GNOME程序都象ps报告一样臃肿...【51CTO.com独家译文】本文是为那些经常疑惑的人准备的,“为什么一个简单的KDE文本编辑器要占用25M内存?”导致大多数人认为许多...
  • Linux实用教程(第三版)

    万次阅读 多人点赞 2019-08-27 22:55:59
    1.2 Linux系统的特点组成 1.3 Linux版本介绍 1.4 Red Hat Linux系统概述 1.1 Linux系统简介 1.1.1 什么是Linux 1.1.2 Linux系统的产生 1.1.3 Linux系统应用领域 1.1.1什么是Linux     ...
  • Linux内存 mem swap

    千次阅读 2019-10-05 20:37:00
    Linux mem/swap/buffers/cached区别  free命令相对于top,提供了更简洁的查看系统内存使用情况:  # free -m  mem:表示物理内存统计  buff/cache:表示物理内存的缓存统计  swap:表示硬盘上交换分区的...
  • Linux内存管理

    千次阅读 2018-02-05 14:49:01
    linux下,使用top,vmstat,free等命令查看系统或者进程的内存使用情况时,经常看到buff/cache memeory,swap,avail Mem等,他们都代表什么意思呢?...讨论Linux下的内存管理其实就是讨论Linux

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 107,192
精华内容 42,876
关键字:

linux内存读速度和写速度

linux 订阅