精华内容
下载资源
问答
  • Qt linux获取cpu使用率、内存、网络收发速度、磁盘读写速度、磁盘剩余空间等,实际上大部分都和qt无关的,用其他语言也可以获取。 code: .h #ifndef RESOURCE_MINITOR_H #define RESOURCE_MINITOR_H #include #...

    Qt linux获取cpu使用率、内存、网络收发速度、磁盘读写速度、磁盘剩余空间等,实际上大部分都和qt无关的,用其他语言也可以获取。
    code:
    .h

    #ifndef RESOURCE_MINITOR_H
    #define RESOURCE_MINITOR_H
    #include <QObject>
    #include <QTimer>
    #include <QProcess>
    #include <QDebug>
    class resource_minitor : public QObject
    {
        Q_OBJECT
    public:
        explicit resource_minitor(QObject *parent = nullptr);
    private slots:
        void get_resource__();
    private:
        bool get_mem_usage__();
        bool get_net_usage__();
        bool get_disk_speed__();
        bool get_cpu_usage__();
        bool get_disk_space__();
        bool get_path_space(const QString & path);
    private:
        const int m_timer_interval__ = 1000;
        QTimer monitor_timer__;
        double m_send_bytes__ = 0;
        double m_recv_bytes__ = 0;
        double m_disk_read__ = 0;
        double m_disk_write__ = 0;
        double m_cpu_total__ = 0;
        double m_cpu_use__ = 0;
    };
    #endif // RESOURCE_MINITOR_H

    .cpp

    #include "resource_minitor.h"
    #include "sys/statfs.h"
    resource_minitor::resource_minitor(QObject *parent) : QObject(parent)
    {
        connect(&monitor_timer__, &QTimer::timeout, this, &resource_minitor::get_resource__);
        monitor_timer__.start(m_timer_interval__);
    }
    void resource_minitor::get_resource__()
    {
        get_cpu_usage__ ();
        get_disk_speed__();
        get_mem_usage__ ();
        get_net_usage__ ();
        get_disk_space__();
        get_path_space("/");
        qDebug()<<"\n";
    }
    bool resource_minitor::get_mem_usage__()
    {
        QProcess process;
        process.start("free -m"); //使用free完成获取
        process.waitForFinished();
        process.readLine();
        QString str = process.readLine();
        str.replace("\n","");
        str.replace(QRegExp("( ){1,}")," ");//将连续空格替换为单个空格 用于分割
        auto lst = str.split(" ");
        if(lst.size() > 6)
        {
            qDebug("mem total:%.0lfMB free:%.0lfMB",lst[1].toDouble(),lst[6].toDouble());
            return true;
        }
        return false;
    }
    bool resource_minitor::get_net_usage__()
    {
        QProcess process;
        process.start("cat /proc/net/dev"); //读取文件/proc/net/dev获取网络收发包数量,再除取样时间得到网络速度
        process.waitForFinished();
        process.readLine();
        process.readLine();
        while(!process.atEnd())
        {
            QString str = process.readLine();
            str.replace("\n","");
            str.replace(QRegExp("( ){1,}")," ");
            auto lst = str.split(" ");
            if(lst.size() > 9 && lst[0] == "enp2s0:")
            {
                double recv = 0;
                double send = 0;
                if(lst.size() > 1)
                    recv = lst[1].toDouble();
                if(lst.size() > 9)
                    send = lst[9].toDouble();
                qDebug("%s 接收速度:%.0lfbyte/s 发送速度:%.0lfbyte/s",lst[0].toStdString().c_str(),(recv - m_recv_bytes__) / (m_timer_interval__ / 1000.0),(send - m_send_bytes__) / (m_timer_interval__ / 1000.0));
                m_recv_bytes__ = recv;
                m_send_bytes__ = send;
            }
        }
        return true;
    }
    bool resource_minitor::get_cpu_usage__()
    {
        QProcess process;
        process.start("cat /proc/stat");
        process.waitForFinished();
        QString str = process.readLine();
        str.replace("\n","");
        str.replace(QRegExp("( ){1,}")," ");
        auto lst = str.split(" ");
        if(lst.size() > 3)
        {
            double use = lst[1].toDouble() + lst[2].toDouble() + lst[3].toDouble();
            double total = 0;
            for(int i = 1;i < lst.size();++i)
                total += lst[i].toDouble();
            if(total - m_cpu_total__ > 0)
            {
                qDebug("cpu rate:%.2lf%%",(use - m_cpu_use__) / (total - m_cpu_total__) * 100.0);
                m_cpu_total__ = total;
                m_cpu_use__ = use;
                return true;
            }
        }
        return false;
    }
    bool resource_minitor::get_disk_speed__()
    {
        QProcess process;
        process.start("iostat -k -d");
        process.waitForFinished();
        process.readLine();
        process.readLine();
        process.readLine();
        QString str = process.readLine();
        str.replace("\n","");
        str.replace(QRegExp("( ){1,}")," ");
        auto lst = str.split(" ");
        if(lst.size() > 5)
        {
            qDebug("disk read:%.0lfkb/s disk write:%.0lfkb/s",(lst[4].toDouble() - m_disk_read__ ) / (m_timer_interval__ / 1000.0),(lst[5].toDouble() - m_disk_write__) / (m_timer_interval__ / 1000.0));
            m_disk_read__ = lst[4].toDouble();
            m_disk_write__ = lst[5].toDouble();
            return true;
        }
        return false;
    }
    bool resource_minitor::get_disk_space__()
    {
        QProcess process;
        process.start("df -k");
        process.waitForFinished();
        process.readLine();
        while(!process.atEnd())
        {
            QString str = process.readLine();
            if(str.startsWith("/dev/sda"))
            {
                str.replace("\n","");
                str.replace(QRegExp("( ){1,}")," ");
                auto lst = str.split(" ");
                if(lst.size() > 5)
                    qDebug("挂载点:%s 已用:%.0lfMB 可用:%.0lfMB",lst[5].toStdString().c_str(),lst[2].toDouble()/1024.0,lst[3].toDouble()/1024.0);
            }
        }
        return true;
    }
    bool resource_minitor::get_path_space(const QString & path)
    {
        struct statfs diskInfo;
        statfs(path.toUtf8().data(), &diskInfo);
        qDebug("%s 总大小:%.0lfMB 可用大小:%.0lfMB",path.toStdString().c_str(),(diskInfo.f_blocks * diskInfo.f_bsize)/1024.0/1024.0,(diskInfo.f_bavail * diskInfo.f_bsize)/1024.0/1024.0);
        return true;
    }

    效果:
    这里写图片描述

    示例代码(Qt5.9工程):http://download.csdn.net/download/yangyang031213/10204938
    https://github.com/yangyang0312/cpp/tree/master/Qt/resource_minitor

    展开全文
  • 事由:使用koolshare的软件中心虚拟内存插件创建swap内存,...【虚拟内存】插件要求USB磁盘设备读取不低于20MB/s,写入速度不低于为30MB/s,此测试速度和USB磁盘实际速度可能有一定差别,以上读写速度仅供参考! 在同等

    事由:使用koolshare的软件中心虚拟内存插件创建swap内存,提示USB磁盘读速度不低于10M/s,写速度不低于30M/s(PS:这不扯犊子吗,哪有U盘写入比读取快的,而且之前随便找个U盘就完事,现在非要搞个高速U盘,又是不小的开支,高端路由器真的是越来越折腾不起了)
    主要报错提示如下:

    USB磁盘[/dev/sdb]的读写速度太低,不符合插件要求!
    【虚拟内存】插件要求USB磁盘设备读取不低于20MB/s,写入速度不低于为30MB/s,此测试速度和USB磁盘实际速度可能有一定差别,以上读写速度仅供参考!
    在同等测试条件下,RT-AC86U,RT-AX88U等机型的flash读为10MB/s,写为30MB/s
    

    附图:原版插件安装提示

    解决方法:

    1. 先使用ssh工具进入路由器后台

      方法:先在路由器后台开启ssh登录,然后用xshell、putty等软件登录,用户名密码就是网页端后台的用户密码

      附上xshell的新建连接设置

    2. 执行一下命令
      sed -i '7,8c R_LIMIT=20\nW_LIMIT=20' /koolshare/scripts/swap_make.sh
      解释一下,就是把创建swap分区的U盘速度限制调整至可用值,值可设置成自己想设置的值(保证外设能达到的水准,不行就往低了调)

      执行完成,再次进入软件中心,即可正常创建虚拟内存。教程完结,生命不息,折腾不止,如有疑问可以评论区留言或者私信博主。


    展开全文
  • kafak读写速度快的原因: 一:生产者写入数据 kafka会把收到的消息都写入到硬盘中,它绝对不会丢失数据,为了优化写入速度kafka采用了两个技术:顺序写入和内存映射文件 1.顺序写入 磁盘读写有...

    kafka的消息是保存或者缓存在磁盘上的,一般认为在磁盘上读写数据会降低性能,因为寻址比较消耗时间。但是实际上,kafka具有高吞吐性,轻松支持
    每秒百万级的写入请求,在海量日志处理场景下广泛应用。
    kafak读写速度快的原因:
    一:生产者写入数据
    kafka会把收到的消息都写入到硬盘中,它绝对不会丢失数据,为了优化写入速度kafka采用了两个技术:顺序写入和内存映射文件
    1.顺序写入
    磁盘读写有两种方式,一种是顺序读写,一种是随机读写,在磁盘的顺序读写情况下,其速度与内存读写速度持平。
    因为磁盘是机械结构,每次读写都会先寻址,再写入,其中寻址是一个机械动作,最耗费时间,所以当顺序读写时,不需要寻址,也就提高了速度。
    甚至其速度快于内存的随机读写。而且linux对于磁盘的读写优化也比较多,包括read-ahead和write-behind,磁盘缓存等。如果在内存做这些操作,
    java对象的内存开销很大,另一个是随着堆内存数据的增多,java的GC时间会变的很长,使用磁盘的好处有:
    1.磁盘的顺序读写超过内存的随机读写
    2.java的GC效率低,内存占用大,使用磁盘可以避免这个问题
    3.系统冷启动后,磁盘缓存依旧可以用
    kafka中的有不同的topic,一个topic又可以有一个或者多个partition,每一个partition都是一个文件,topic收到消息后,会将这些数据插入
    partition文件的末尾。但是这种方法不可以删除数据,所以kafka会把所有的数据都保留下来,再根据时间或者partition文件的大小进行删除。
    每一个消费者
    2.内存映射文件:
    内存映射文件相当于一块虚拟内存,大小有20G,可以保留一个地址空间的区域,同时将物理存储器提交给此区域,内存文件映射的物理存储器来自
    一个已经存在于磁盘上的文件,当使用了内存映射文件时,当你在处理它在磁盘上对应的那个文件时,就不必再对文件执行IO操作,这样极大提高
    了IO效率,因为这相当于读写内存一样读写磁盘。但是这有一缺点是不可靠,因为在内存映射文件中的数据没有真正的写到硬盘。只有当系统调用
    flush的时候才会把数据真正的写入磁盘。kafka有一个参数producer.type是用来控制是不是主动flush。
    二:消费者读取数据:
    1.基于sendfile实现zero copy
    传统模式下,当对一个文件进行传输时,具体的流程如下:
    1.调用read函数,文件数据被copy到内核缓冲区
    2.read函数返回,文件数据从内核缓冲区copy到用户缓冲区
    3.write函数调用,将文件数据从用户缓冲区copy到内核与socket相关的缓冲区
    4.数据从socket缓冲区copy到相关协议引擎
    传统模式下进行网络文件传输的过程中,实际上进行了四次copy操作。但是sendfile系统调用减少了多次copy,提升文件传输效率。
    kafka把所有的消息都存储在一个个的文件中,当消费者需要数据的时候,kafka将文件直接通过sendfile的方式发送给消费者,提高了效率。
    并且该方式还提供了从指定偏移量发送文件的功能,消费者保存着偏移量,每次请求时,都会发送这个偏移量,sendfile会把这个文件按照
    指定偏移量进行发送。
    2.批量压缩:
    很多时候,系统的瓶颈不是CPU和磁盘,而是网络IO,kafka会对数据进行批量压缩,虽然这样会消耗CPU资源,但是对kafka而言,这些CPU资源
    很少,况且相对于CPU资源,由于批量压缩而减少的网络IO更值得kafka考虑。
    总结:kafka速度快的原因就在于,把所有的消息都变成一个个文件,并通过合理的批量压缩形式减少网络IO损耗,通过内存映射文件提供IO速度,写入数据的
    时候由于是末尾添加,所以速度最优,消费时,通过sendfile方式达到减少copy操作,直接输出,提升文件传输效率。

    kafka的文件存储机制:
    kafka中可以有多个不同的topic,用来存储不同类型的数据。而每一个topic下又有多个或者一个partition,每一个partition在实际中是一个目录。
    在kafka的配置文件中可以配置partition文件存放的目录。每一个partition相当于一个巨型文件被平均分配到多个大小相等的segment数据文件中,
    每个segment文件大小不一定相等,主要为了方便删除过期的数据,而每个partition只需要支持顺序读写就完事了。
    segment文件由两部分组成,一个是数据文件,以.log结尾,一个是数据文件对应的索引文件,以.index结尾。segment文件命令规则是,第一个segment
    文件是16位的0,后续的segment文件是以上一个segment文件最后一条消息的偏移量为名作为名字的。这样做主要是为了方便消费者通过索引文件快速的
    找到自己需要的消息。

    kafka高效文件存储设计的特点:
    1.kafka把topic中的一个个partition分成多个小文件段,通过多个小文件段,容易定期清除数据,减少磁盘的占用
    2.通过索引信息可以快速的找到需要的信息
    3.通过索引元数据全部映射到内存,可以避免segment file的IO磁盘操作
    4.通过索引文件稀疏存储,可以大幅度降低索引文件元数据占用的空间。

    kafka中的topic有多个partition,是如何保证顺序读取的?
    kafka的partition内存时强有序的,但是partition之间不是有序的。

    一个分区只能被同组的一个消费者消费,同组的消费者起到均衡作用。

    当消费者数量大于主题的分区数量:
    如果某个主题只有一个分区,而现在启动两个消费者去消费该主题。并且这个两个消费者同属于一个消费者组,那么只有一个消费者能够消费得到数据,另一个消费者
    空闲。即同一个分区内的消息只能被同一个组中的一个消费者消费,当消费者数量多于分区数量时,多于的消费者空闲。分区的数量决定了该主题在同一组中可被均衡
    的程度,比如有4个分区,则可在同一组中被最多4个消费者均衡消费。

    当消费者数量小于或等于分区数量:
    比如一个主题有三个分区,在同一个消费者中启动2个消费者去消费该主题,则其中一个消费者会消费两个分区,另一个消费者消费一个分区。如果数据在分区之间是
    均匀分布的话,消费两个分区的消费者所消费的数据量是另一个的两倍。但是如果在这个消费者组中再启动一个消费者的话,也就是有三个分区和三个消费者,那么
    分区与消费者的将会一一对应。

    多个消费者组:
    当多个消费者组消费同一个主题时,比如某主题有三个分区,同时被两个消费者组A和B消费,A中有三个消费者,B中一个消费者。
    那么A中的三个消费者会一一对应于主题的三个分区,而B中的一个消费者会独立消费该主题的三个分区。

    对于同一个主题,不同的消费者组之间互不影响。

    展开全文
  • 数据库I/O读写速度

    2019-10-09 07:06:17
    工作中遇到的一个实际问题。 问题如下: 长时间,大量插入数据的速度慢的问题。 7*24小时的不间断想数据库中插入数据,单表的插入数据量平均目前平均35条/秒。有 40多个单表表都需要插入。插入数据的同时...

    工作中遇到的一个实际问题。

    问题如下:
    长时间,大量插入数据的速度慢的问题。
    7*24小时的不间断想数据库中插入数据,单表的插入数据量平均目前平均35条/秒。有

    40多个单表表都需要插入。插入数据的同时还要对40多个单表进行更新和查询操作。
    如此频繁的对数据库进行操作的情况下,数据库的速度已经不能满足我们的需求了。

    经过了一系列的SQL文,内存设置,缓存设置之后还是无法满足。
    最后经过在linux下top进行分析,发现原来是orcale的I/O读写速度问题。并且硬盘处

    理速度不及时还导致CPU %WA等待。
    经过统计情况如下:
    插入量:40*35=1400条/秒
    查询量:40*100=4000条/秒
    更新量:40*10=400条/秒
    删除量:1400*66%=900条/秒
    每秒处理共约:6700条数据。
    这样一个int占4个字节,一个double占8个字节,一个varchar(200)占200个字节.....
    一条数据有 800~1400个字节 按照平均一条数据1024个字节来算,就是1条数据占用

    1Kb的空间。
    那么硬盘最少要有6700*1Kb =6.7M 的读写速度。本来我们用的硬盘是7200的,极限的

    读写速度是30M-40M/秒左右,为什么6.7M左右就承受不住了呢?
    经过分析认为,硬盘的测试速度只是单一的读写。但是在频繁的读写删除面前远远达不到那个速度(磁头不停的切换,扇区不停的反转)
    注意:这里请不要长生误区:6.7M是每秒的读写速度,由于我做了优化每秒还会删除插入数据的66%,这样最后保存到磁盘的每秒只有400K左右。
    一天40G的数据 平均每秒400多K。

     

    解决方案:表分区 + 磁盘阵列 + RAID0. 理论上能提高几十倍甚至几百倍的速度。
                   具体实现细节。。。略。。。。。。。

    如果有人有兴趣知道可以留言探讨。

    转载于:https://www.cnblogs.com/mooreliu/p/4850033.html

    展开全文
  • 内存映射是将磁盘上某文件的一部分或整个文件映射到应用程序地址空间内某个地址范围的一种...1.读写二进制文件将int16二进制文件映射到内存中,跳过前1000个字节。注意是字节,不是数的个数。对于int16类型来说,相...
  • Ddr2,ddr3,ddr4内存条的读写速率

    千次阅读 2018-10-22 09:21:00
    理论极限值是可以计算的:1333MHz * 64bit(单通道,双通道则128bit) / 8(位到字节单位转换) = 10.664GB/s。这只是理论,实际发挥还要看...实际见过的像RamDisk之类的软件,连续读写能达到的速度也不过5~8GB/s左...
  • 3、该内存库只允许一个模块写入, 但可多个模块读取, 但需要各个读取模块没有任何相互干扰, 比如一个模块可能读取的速度较慢, 一个读取的速度较快 4、该内存库需要具有一定的数据缓冲, 实际的应用上, ...
  • 工作中遇到的一个实际问题。问题如下:长时间,大量插入数据的速度慢的问题。7*24小时的不间断想数据库中插入数据,单表的插入数据量平均目前平均35条/秒。有40多个单表表都需要插入。插入数据的同时还要对40多个单...
  • 理论极限值是可以计算的:1333MHz * 64bit(单通道,双通道则128bit) / 8(位到字节单位转换) = 10.664GB/s。这只是理论,实际发挥还要看内存...实际见过的像RamDisk之类的软件,连续读写能达到的速度也不过5~8GB/s左...
  • 内存映射是将磁盘上某文件的一部分或整个文件映射到应用程序地址空间内某个地址范围的一种...1.读写二进制文件将int16二进制文件映射到内存中,跳过前1000个字节。注意是字节,不是数的个数。对于int16类型来说,相...
  • wmic memorychip。打开命令提示符,输入wmic memorychip,按回车键。 通过内存读写速度测试工具查看
  • 它不仅仅是[color=red]测量运行时间,还可以测量内存、I/O[/color]等的使用情况。一个程序在运行时使用的系统资源通常包括CPU、Memory和I/O等,其中[color=red]CPU资源的统计[/color]包括实际使用时间(real time)...
  • 内存映射是将磁盘上某文件的一部分或整个文件映射到应用程序地址空间内某个地址范围的一种...1.读写二进制文件将int16二进制文件映射到内存中,跳过前1000个字节。注意是字节,不是数的个数。对于int16类型来说,相...
  • 内存与虚拟内存

    2019-02-26 12:46:07
    对于读写速度内存 &gt; 固态硬盘 &gt; 机械硬盘。机械硬盘是靠电机带动盘片转动来读写数据的,而内存条通过电路来读写数据,电机的转速肯定没有电的传输速度(几乎是光速)快。虽然固态硬盘也是通过电路来...
  • 引言:读写大“二进制”文件,不必申请很大内存(fopen、fread、fwrite、fclose)!做到开源节流,提高速度! 每天告诉自己一次,『我真的很不错』.... 加速读写大文件,在实际工作过程当中其实想必很多人都有...
  • 既然建立内存映射没有进行实际的数据拷贝,那么进程又怎么能最终直接通过内存操作访问到硬盘上的文件呢?那就要看内存映射之后的几个相关的过程了。 mmap()会返回一个指针ptr,它指向进程逻辑地址空间中的一个...
  • Linux 文件读写机制

    2021-01-23 21:54:06
    缓存是用来减少高速设备访问低速设备所需平均时间的组件,文件读写涉及到计算机内存和磁盘,内存操作速度远远大于磁盘,如果每次调用read、write都去直接操作磁盘,一方面速度会被限制,一方面也会降低磁盘使用寿命...
  • swap,它还可以将它们映射到文件和文件位置,这样,读写内存将对文件中的数据进行读写。不过,在这里,我们只关心 mmap 向进程添加被映射的内存的能力。munmap() 所做的事情与 mmap() 相反。 如您所见,brk() ...
  • Linux文件读写与缓存

    2018-01-24 23:55:07
    缓存是用来减少高速设备访问低速设备所需平均时间的组件,文件读写涉及到计算机内存和磁盘,内存操作速度远远大于磁盘,如果每次调用read,write都去直接操作磁盘,一方面速度会被限制,一方面也会降低磁盘使用寿命,...
  • 为了解决CPU运算速度和物理内存读写速度之间的巨大差异,Java引入了高速缓存的概念,缓存的读写速度和CPU速度差不多。即主内存和工作内存,主内存对应实际的物理内存,每一个线程都有自己的工作内存,所有的数据都...
  • 缓存的出现主要是为了解决CPU运算速度与内存读写速度不匹配的矛盾,因为CPU运算速度要比内存读写速度快很多,这样会使CPU花费很长时间等待数据到来或把数据写入内存。  缓存大小是CPU的重要指标之一,而且缓存的...
  • Linux对文件读写并不是每次都进行磁盘IO,而是将对应的磁盘文件缓存到内存上,之后对该文件的操作实际上也是对内存读写。 缓存俗称:page cache页缓存 而被修改过但还没写入磁盘的页缓存泽称为:dirty page脏页 ...
  • linux内存相关

    2014-03-22 22:22:11
    当然它的读写速度肯定不能跟真正的物理内存匹敌。 linux的内存管理采取的是分页存取机制,为了保证物理内存能得到充分的利用,内核会在适当的时候将物理内存中不经常使用的数据块自动交换到虚拟内
  • 我们平时习惯用存取时间的倒数来表示速度,比如6ns的内存实际频率为1/6ns=166MHz(如果是DDR就标DDR333,DDR2就标DDR2 667)。 4.内存延迟 内存的延迟时间(也就是所谓的潜伏期,从FSB到DRAM)等于下列时间的综合...

空空如也

空空如也

1 2 3 4 5 ... 14
收藏数 261
精华内容 104
关键字:

内存实际读写速度