精华内容
下载资源
问答
  • 读写数据库与读写文件速度实例测试
    2020-11-02 12:21:51

    由于开发物流信息网,关于这个问题也是最近才想到的,就是到底读文件更快还是读数据库更快,能快多少,书生也搜索过,没见有网友就这个问题答复过, 也可能是太简单的缘故,我们本文还是来实测一下,由于时间关系,VC还没装,书生先用PHP测试了一下,下次有时间在C/C++上补充测试到本文来,因为 PHP的底层解析应该也是基于C的,所以估计两者环境测试结果差不多,小问题大收获,现在就来看一下测试过程及结果。

    测试程序如下:

    //说明1:由于读数据库语句调用简单的封包函数两次,所以把读文件也改成连续调用两次,数据库记录ID为1就在第一条,并且唯一索引。

    //说明2:测试两次一次是4K数据,一次是整形数据

    set_time_limit(0);

    function fnGet($filename)
    {
        $content = file_get_contents($filename);
        return $content;
    }

    function fnGetContent($filename)
    {
        $content = fnGet($filename);
        return $content;
    }
        
    $times=100000;    
    echo '数据库查询结果:<br/>';
    //---------------------------------
    $begin=fnGetMicroTime();
    for($i=0;$i<$times;$i++)
    {
        $res=$dbcon->mydb_query("SELECT log_Content FROM blog WHERE log_ID='1'");
        $row=$dbcon->mydb_fetch_row($res);
        $content=$row[0];
    }
    echo 'fetch_row '.$times.' 次时间:<font color=red>'.(fnGetMicroTime()-$begin).'</font>秒<br/>';
    //---------------------------------

    $begin=fnGetMicroTime();
    for($i=0;$i<$times;$i++)
    {
        $res=$dbcon->mydb_query("SELECT log_Content FROM blog WHERE log_ID='1'");
        $row=$dbcon->mydb_fetch_array($res);
        $content=$row['log_Content'];    
    }
    echo 'fetch_array '.$times.' 次时间:<font color=red>'.(fnGetMicroTime()-$begin).'</font>秒<br/>';
    //---------------------------------

    $begin=fnGetMicroTime();
    for($i=0;$i<$times;$i++)
    {
        $res=$dbcon->mydb_query("SELECT log_Content FROM blog WHERE log_ID='1'");
        $row=$dbcon->mydb_fetch_object($res);
        $content=$row->log_Content;    
    }
    echo 'fetch_object '.$times.' 次时间:<font color=red>'.(fnGetMicroTime()-$begin).'</font>秒<br/>';
    //---------------------------------

    $dbcon->mydb_free_results();
    $dbcon->mydb_disconnect();

    fnWriteCache('test.txt',$content);

    echo '直接读文件测试结果:<br/>';

    //---------------------------------
    $begin=fnGetMicroTime();
    for($i=0;$i<$times;$i++)
    {
        $content = fnGetContent('test.txt');
    }
    echo 'file_get_contents直接读'.$times.'次时间:<font color=red>'.(fnGetMicroTime()-$begin).'</font>秒<br/>';
    //---------------------------------

    $begin=fnGetMicroTime();
    for($i=0;$i<$times;$i++)
    {
        $fname = 'test.txt';
        if(file_exists($fname))
         {
            $fp=fopen($fname,"r");//flock($fp,LOCK_EX);        
            $file_data=fread($fp, filesize($fname));//rewind($fp);       
            fclose($fp);
        }
        $content = fnGetContent('test.txt');
    }    
    echo 'fopen直接读'.$times.'次时间:<font color=red>'.(fnGetMicroTime()-$begin).'</font>秒<br/>';

    4K大小数据的查询结果:

    fetch_row 100000 次时间:16.737720012665

    fetch_array 100000 次时间:16.661195993423

    fetch_object 100000 次时间:16.775065898895

    直接读文件测试结果:

    file_get_contents直接读100000次时间:5.4631857872009

    fopen直接读100000次时间:11.463611125946

    整形ID查询结果:

    fetch_row 100000 次时间:12.812072038651

    fetch_array 100000 次时间:12.667390108109

    fetch_object 100000 次时间:12.988099098206

    直接读文件测试结果:

    file_get_contents直接读100000次时间:5.6616430282593

    fopen直接读100000次时间:11.542816877365

     

    测试结论:

    1、直接读文件相比数据库查询效率更胜一筹,而且文中还没算上连接和断开的时间。

    2、一次读取的内容越大,直接读文件的优势会越明显(读文件时间都是小幅增长,这跟文件存储的连续性和簇大小等有关系),这个结果恰恰跟书生预料的相反,说明MYSQL对更大文件读取可能又附加了某些操作(两次时间增长了近30%),如果只是单纯的赋值转换应该是差异偏小才对。

    3、写文件和INSERT几乎不用测试就可以推测出,数据库效率只会更差。

    4、很小的配置文件如果不需要使用到数据库特性,更加适合放到独立文件里存取,无需单独创建数据表或记录,很大的文件比如图片、音乐等采用文件存储更为方便,只把路径或缩略图等索引信息放到数据库里更合理一些。

    5、PHP上如果只是读文件,file_get_contents比fopen、fclose更有效率,不包括判断存在这个函数时间会少3秒左右。

    6、fetch_row和fetch_object应该是从fetch_array转换而来的,书生没看过PHP的源码,单从执行上就可以说明fetch_array效率更高,这跟网上的说法似乎相反。

    实 际上在做这个试验之前,从个人经验判断就有了大概的结果,测试完成后则有种豁然开朗的感觉。假定在程序效率和关键过程相当且不计入缓存等措施的条件下,读 写任何类型的数据都没有直接操作文件来的快,不论MSYQL过程如何,最后都要到磁盘上去读这个“文件”(记录存储区等效),所以当然这一切的前提是只读 内容,无关任何排序或查找操作。

    更多相关内容
  • 行业分类-设备装置-加速空间大数据文件读写速度的方法.zip
  • 测试nfs文件读写速度

    千次阅读 2018-11-10 09:42:59
    luther@gliethttp:~$ time dd if=/dev/zero of=/nfs/testfile bs=8k count=1024 这是来测试nfs写  luther@gliethttp:~$ time dd if=/nfs/testfile of=/dev/null bs=8k count=1024 这是测试nfs读

    luther@gliethttp:~$ time dd if=/dev/zero of=/nfs/testfile bs=8k count=1024 这是来测试nfs写 
    luther@gliethttp:~$ time dd if=/nfs/testfile of=/dev/null bs=8k count=1024 这是测试nfs读

    展开全文
  • 速度比windows的API要快很多,数据量大的情况下对比更明显。代码中有两种方法的比较并记录。
  • Windows文件读写速度

    千次阅读 2013-09-01 14:27:51
    这几天在研究怎么才能加快windows文件读写速度,搜了很多文章,MSDN也看了不少。稍微给大家分享一下。 限制windows文件读写速度的瓶颈其实最终还是来源于我们硬盘的固有特性,磁盘本身的转速和硬盘的串行化工作机制...
           这几天在研究怎么才能加快windows文件读写速度,搜了很多文章,MSDN也看了不少。稍微给大家分享一下。
           限制windows文件读写速度的瓶颈其实最终还是来源于我们硬盘的固有特性,磁盘本身的转速和硬盘的串行化工作机制。我们所能做的只是改善软件实现方法去逼近硬盘的极限读写速度。平时我们在拷贝粘贴文件的时候,其实是用的windows本身的实现,其中有一个很大的影响速度的地方就是它们都用了windows的文件缓存机制,当你拷贝一个大文件时,windows会根据你要拷贝的文件大小缓存很大一部分到系统缓存,这时候你会看到系统缓存瞬间飙涨,机器性能大大降低。整体拷贝速度为10M/S左右。而IDE 7200转的硬盘读写速度一般能达到30M/S左右,所以浪费了很大一部分硬盘读写速度。而当我们并行读写多个文件时,速度比串行读写多个文件还要慢,这就是因为硬盘串行工作机制的限制,多文件并行操作时,时间都花在磁头摆动上了。并且在缓存读取上,命中率也将大大降低。所以我们要避免使用windows缓存机制,并尽量不要同时读写多段文件,尽量读写连续的文件块。
           一般来说,我们操作一个windows I/O句柄用的是windows文件读写系列API:CreateFile, ReadFile, WriteFile等,这些API不仅可以读写文件句柄,所有的I/O设备句柄都能通过这些API来操作。比如socket描述符,  串口描述符,管道描述符等。通过设置他们的参数,我们可以选择以不同的方式操作IO。例如CreateFile,原型如下:

    HANDLE CreateFile(
    LPCTSTR lpFileName, //指向文件名的指针
    DWORD dwDesiredAccess, //访问模式(写/读)
    DWORD dwShareMode, //共享模式
    LPSECURITY_ATTRIBUTES lpSecurityAttributes, //指向安全属性的指针
    DWORD dwCreationDisposition, //如何创建
    DWORD dwFlagsAndAttributes, //文件属性
    HANDLE hTemplateFile //用于复制文件句柄
    );

    对于读写速度,最重要的是dwFlagsAndAttributes参数,这个参数的取值可以参看MSDN,这里稍微说一下:

    Attributes:
    该参数可以接收下列属性的任意组合.除非其它所有的文件属性忽略FILE_ATTRIBUTE_NORMAL.
    FILE_ATTRIBUTE_ARCHIVE 文件将被存档,程序使用此属性来标志文件去备份或移除

    FILE_ATTRIBUTE_HIDDEN 文件被隐藏,它不会在一般文件夹列表中被装载.

    FILE_ATTRIBUTE_NORMAL 文件没有被设置任何属性.

    FILE_ATTRIBUTE_OFFLINE 文件的数据没有被立即用到。指出正在脱机使用该文件。

    FILE_ATTRIBUTE_READONLY 这个文件只可读取.程序可以读文件,但不可以在上面写入内容,也不可删除.

    FILE_ATTRIBUTE_SYSTEM 文件是系统的一部分,或是系统专用的.

    FILE_ATTRIBUTE_TEMPORARY 文件被使用后,文件系统将努力为(文件的)所有数据的迅迅访问保持一块内存。临时文件应当在程序不用时及时删除。

    Flags:

    可以接受下列标志的任意组合。

    FILE_FLAG_WRITE_THROUGH

    指示系统通过快速缓存直接写入磁盘,

    FILE_FLAG_OVERLAPPED

    指示系统初始化对象, 此操作将对进程设置一个引用计数并返回ERROR_IO_PENDING.处理完成后, 指定对象将被设置为信号状态.当你指定FILE_FLAG_OVERLAPPED时,读写文件的函数必须指定一个OVERLAPPED结构.并且. 当FILE_FLAG_OVERLAPPED被指定, 程序必须执行重叠参数(指向OVERLAPPED结构)去进行文件的读写. 这个标志也可以有超过一个操作去执行.

    FILE_FLAG_NO_BUFFERING

    指示系统不使用快速缓冲区或缓存,当和FILE_FLAG_OVERLAPPED组合,该标志给出最大的异步操作量, 因为I/O不依赖内存管理器的异步操作.然而,一些I/O操作将会运行得长一些,因为数据没有控制在缓存中.

    当使用FILE_FLAG_NO_BUFFERING打开文件进行工作时,程序必须达到下列要求:

    1. 文件的存取开头的字节偏移量必须是扇区尺寸的整倍数.
    2. 文件存取的字节数必须是扇区尺寸的整倍数.例如,如果扇区尺寸是512字节.程序就可以读或者写512,1024或者2048字节,但不能够是335,981或者7171字节.

    3. 进行读和写操作的地址必须在扇区的对齐位置,在内存中对齐的地址是扇区.尺寸的整倍数.一个将缓冲区与扇区尺寸对齐的途径是使用VirtualAlloc函数.它分配与操作系统内存页大小的整倍数对齐的内存地址.因为内存页尺寸和扇区尺寸--2都是它们的幂.这块内存在地址中同样与扇区尺寸大小的整倍数对齐.程序可以通过调用GetDiskFreeSpace来确定扇区的尺寸.

    FILE_FLAG_RANDOM_ACCESS
    指定文件是随机访问,这个标志可以使系统优化文件的缓冲.

    FILE_FLAG_SEQUENTIAL_SCAN 
    指定文件将从头到尾连续地访问.这个标志可以提示系统优化文件缓冲. 如果程序在随机访问文件中移动文件指针,优化可能不会发生;然而,正确的操作仍然可以得到保 证. 指定这个标志可以提高程序以顺序访问模式读取大文件的性能, 性能的提高在许多程序读取一些大的顺序文件时是异常明显的.但是可能会有小范围的字节遗漏.

    FILE_FLAG_DELETE_ON_CLOSE

    指示系统在文件所有打开的句柄关闭后立即删除文件.不只有你指定了FILE_FLAG_DELETE_ON_CLOSE的文件。
    FILE_SHARE_DELETE
    如果没有使用FILE_SHARE_DELETE,后续的打开文件的请求将会失败.

    FILE_FLAG_BACKUP_SEMANTICS

    WINDOWS NT:指示系统为文件的打开或创建执行一个备份或恢复操作. 系统保证调用进程忽略文件的安全选项,倘若它必须有一个特权.则相关的特权则是SE_BACKUP_NAME和SE_RESTORE_NAME.你也可以使用这个标志获得一个文件夹的句柄,一个文件夹句柄能够象一个文件句柄一样传给某些Win32函数。

    FILE_FLAG_POSIX_SEMANTICS

    指明文件符合POSIX标准.这是在MS-DOS与16位Windows下的标准.

    FILE_FLAG_OPEN_REPARSE_POINT

    指定这个标志制约NTFS分区指针.该标志不能够和CREAT_ALWAYS一起使用.

    FILE_FLAG_OPEN_NO_RECALL

    指明需要文件数据,但是将继续从远程存储器中接收.它不会将数据存放在本地存储器中.这个标志由远程存储系统或等级存储管理器系统使用.

    可以看到,有很多标志和属性可以使用,但是这里最重要的对速度影响最大的是红字部分的FILE_FLAG_NO_BUFFERING和FILE_FLAG_OVERLAPPED.

    FILE_FLAG_NO_BUFFERING就是说文件操作时不使用windows缓存机制,FILE_FLAG_OVERLAPPED则表示文件的操作将异步进行。就是说不等待I/O操作完成,读写函数便返回,这要用到重叠IO机制,自己针对IO状态做不同的事情,基本上用到的是GetOverlappedResult和WaitForMultiObject。

    当我单独使用FILE_FLAG_NO_BUFFERING时,拷贝粘贴一个400M文件大概22秒,接近20M/S的速度,但是指定FILE_FLAG_NO_BUFFERING时,文件位置,缓存大小,文件大小都有很大的限制,即都要和扇区大小对齐(见红字部分)。如果不这样,读写将失败。这的确增大了不少内存分配操作,但是速度提高却很明显。

    而当我使用FILE_FLAG_OVERLAPPED将文件分为多个部分同时读写时,发现速度反而慢了。回到开头说的,这就是硬盘本身的限制了。但是我参考Fastcopy(一个免费文件拷贝软件)源代码时,发现它也同时打开了多个文件读写。可是速度却没有慢多少。具体原因还得研究研究。

    以上都是在本地硬盘操作的情况下,没有网络的限制,而当我要在服务器上拷贝文件时,最大的瓶颈便成了网络。在这种情况下,我的想法是,服务器的硬盘读取速度应该大大高于我们的机器硬盘,所以可以将文件分多段同时读取,以争取网络带宽,而在写入时则以串行的方式写入连续的文件。这样既能充分利用网络,又能避免本地硬盘的读写速度限制。当然,具体效果还须回公司试验。

    展开全文
  • 主要介绍了Centos7利用内存优化磁盘缓存读写速度的方法,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 通过往U盘或其他USB工具内部写入文件或读取文件测试,分别测试100M,10M,1M,1K不同大小的读写速度
  • 实时检测USB的插入,检测并读取文件,也可根据路径进行文件读写操作
  • 主要介绍了Java文件读写IO/NIO及性能比较详细代码及总结,具有一定借鉴价值,需要的朋友可以参考下。
  • 在有时候,项目的数据量特别大,而且源源不断的到来,这个时候,利用传统的IO文件流写文件势必效率很低跟不上节奏,这时候采用内存映射提高读写效率
  • 本文介绍了Linux下各种主要文件系统的读写性能测试方法。
  • 本文实例为大家分享了python多线程同步之文件读写控制的具体代码,供大家参考,具体内容如下 1、实现文件读写的文件ltz_schedule_times.py #! /usr/bin/env python #coding=utf-8 import os def ReadTimes(): res ...
  • 对大数据文本文件读取(按行读取)的优化,目前常规的方案有三种,第一种LineNumberReader,第二种RandomAccessFile,第三种是内存映射文件在RandomAccessFile基础上调用getChannel().map(...);代码提供在...
  • 在Linux环境下测试大文件(超过2G)的读写效率
  • 今天小编就为大家分享一篇android 识别U盘以及读写文件的方法,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 标准C/C++读写配置文件类,读写ini文件,加入工程就可以用. 非常完美的封装类,利用SET容器储存,速度非常快。
  • matlab开发-读写速度文件。此代码允许读取/写入.spe文件
  • 测试磁盘读写速度 对于这个实验,结合实验给出的样例,不难分析出需要的几个小知识点:malloc创建缓冲区,open、write、read这三个文件操作函数的使用以及gettimeofday()函数以及时间结构体的使用。 获取时间 ...

    前言

    这几天换季了,身边的很多人包括自己都感冒了,大家要注意保暖防寒,适当运动,规律作息。这期的blog本来想分两期做的,结果这几天一直重感冒,拖到了现在,索性就来个二合一。
    完整代码在文末

    测试磁盘读写速度

    对于这个实验,结合实验给出的样例,不难分析出需要的几个小知识点:malloc创建缓冲区,open、write、read这三个文件操作函数的使用以及gettimeofday()函数以及时间结构体的使用。

    获取时间

    时间结构体

    struct timeval {
        time_t      tv_sec;     /* 秒*/
        suseconds_t tv_usec;    /* 微秒*/
    };
    
    

    以及 获取当前时间函数的声明

    int gettimeofday(struct timeval *tv, struct timezone *tz);
    

    二者的头文件

    #include <sys/time.h>
    

    相关使用可以参考如下例子

    struct timeval startTime, endTime;
    gettimeofday(&startTime, NULL);
    //语句块;
    gettimeofday(&endTime, NULL);
    double timeElapse=(double)( endTime. tv_sec - startTime.tv_sec)*1000.0 + (double) ( endTime. tv_usec- startTime.tv_usec)/1000.0;
    
    

    最终得到的timeElapse即为执行语句块所需的时间。当然,很容易可以知道,单位是毫秒。

    创建缓冲区

    头文件

    #include<stdlib.h>
    

    malloc创建缓冲区

    char* buffer = (char*)malloc(sizeof(char) * 100 * MB);
    

    这里强调一点,不能使用char buffer[] 来代替char* buffer,在linux下是不能通过gcc编译的,至于原因,个人觉得是前者属于将buffer视为一个数组,而后者才是一个字符串,或者是因为malloc创建的缓冲区以char*,不允许类型转换成char[]

    文件操作函数

    open

    #include <sys/stat.h>
    #include <fcntl.h>
    int open(const char *path, int oflag);
    int open(const char *path, int oflag, mode_t mode);
    
    

    相关介绍如上,可以发现open函数的第三个参数可以有也可以没有,第三个参数表示文件的权限,mode用于指定文件创建时的访问权限。当传入mode参数后,文件的访问权限为mode&(~umask)。然后我们再看下linux下的输出
    在这里插入图片描述
    在这里插入图片描述
    这就是不传mode和传mode的区别,不传的话open默认为550( 当不传入第三个参数时,即使用只含有两个参数的open,新创建的文件访问权限由底层算法指定。),我们指定了后输出一个644的权限,和mode一样,欸,前面不是还说会和umask取反做按位与嘛,怎么还是不变?因为我们的umask被我们设置为了001,所以最终输出的文件的权限也是0644。
    在这里插入图片描述

    write和read

    #include <unistd.h>
    size_t read(int fd, void *buf, size_t count);
    size_t write(int fd, const void *buf, size_t count);
    int close(int fd);
    
    

    fd为文件描述符的int变量,由open函数返回得到,当fd < 0,时表示open失败。

    代码思路

    1. 创建缓冲区
    2. 读写文件前后分别获取当前时间
    3. 用缓冲区比上获得的时间段即可

    进程并发

    两个比较重要的先导知识,fork() 和 wait() 函数

    fork()函数:
    创建子进程,同时会返回一个值,根据返回的值,我们可以判断创建子进程是否成功,以及当时处于父进程还是子进程。
    wait()函数
    我们一般使用wait(NULL),其作用是使当前最近的一个子进程结束,然后执行父进程,一般用于父进程中。

    关于这两个函数以及并发的思路,我都是参照下列这位大大的blog,有需要的可以看看
    链接

    关于进程以及并发,首先要明确的1点是在该实验中,两个进程一个是compute进程,一个是IO进程,这两个进程一个主要占用的是CPU,另一个是IO这样的临界资源。对于一般的OS,我们默认cpu只有一个,因此CPU每次只能执行一个进程,而并发的好处在于其可以CPU执行一个进程,另外的资源(比如IO)执行另一个进程。
    使用fork创建的父子进程会并发执行所有进程,当然由于cpu只有一个,且其中一个进程占cpu的时间会较长,所以相对来说,需要wait()去等待执行完子进程。

    以下是源码
    (测试读写速度)

    #include<stdio.h>
    #include<stdlib.h>
    #include<string.h>
    #include<sys/stat.h>
    #include<fcntl.h>
    #include<unistd.h>
    #include<sys/time.h>
    
    #define MB 1048576
    
    int main(int argc, char* argv[])
    {
        char filename[] = "myfile05";
        // 100MB
        char* buffer = (char*)malloc(sizeof(char) * 100 * MB);
        buffer[MB] = '\0';
        size_t bufSize =  100 * MB * 5;
    
        struct timeval startWriteTime, endWriteTime;
    
        gettimeofday(&startWriteTime, NULL);
    
        int fd;
        fd = open(filename, O_RDWR | O_CREAT, 0777);
        if (fd < 0)
        {
            perror("Unable to  creat file");
            return -1;
        }
    
        size_t sizeWrited = write(fd, (void*)buffer, bufSize);
        printf("Write:%ldbytes to %s\n", sizeWrited, filename);
        gettimeofday(&endWriteTime, NULL);
        close(fd);
        double wirteTimeElapse = (double)(endWriteTime.tv_sec - startWriteTime.tv_sec) * 1000.0 + (double)(endWriteTime.tv_usec - startWriteTime.tv_usec) / 1000.0;
        double Vol_Write = sizeWrited * 1.0f * 1000/ wirteTimeElapse / MB;
        printf(" %lfMB/s\n", Vol_Write);
    
        fd = open(filename, O_RDWR);
        if (fd < 0)
        {
            perror("Unable to open file");
            return -1;
        }
    
        struct timeval readStime, readEtime;
        gettimeofday(&readStime, NULL);
        size_t sizeRead = read(fd, (void*)buffer, bufSize);
        gettimeofday(&readEtime, NULL);
        printf("Read:%ld bytes from %s, read content:%s\n", sizeWrited, filename, buffer);
        double ReadTime = (double)(readEtime.tv_sec - readStime.tv_sec) * 1000.0 + (double)(readEtime.tv_usec - readStime.tv_usec) / 1000.0;
        double Vol_read = sizeRead * 1.0f * 1000/ ReadTime / MB;
        printf("%lfMB/s\n", Vol_read);
        return 0;
    }
    
    
    
    

    (并发)

    #include <stdio.h>
    #include <stdlib.h>
    #include <sys/types.h>
    #include <sys/wait.h>
    #include <sys/time.h>
    #include <unistd.h>
    
    #include "ComputeTask.h"
    #include "IOTask.h"
    
    typedef enum OP{
    
    	COMPUTE_TASK=1,
    	IO_TASK
    }OP_t;
    
    typedef struct task{
    	struct task *next;
    	OP_t taskType;
    }task_t;
    
    int main(int argc, char *argv[])
    {
    	double computeTaskTimeElapse=0.0;
    	double IOTaskTimeElapse=0.0;
    	double totalTimeElapse=0.0;
    
    	struct timeval computeTaskStartTime, computeTaskEndTime,IOTaskStartTime, IOTaskEndTime;
    	
    	pid_t fpid;
    	task_t computeTask, ioTask;
    	task_t* curTask = &ioTask;
    
    	computeTask.taskType = COMPUTE_TASK;
    	ioTask.next=&computeTask;
    	ioTask.taskType=IO_TASK;
    	computeTask.next=NULL;
    
    	int parentProcess = 1;
    	int childProcessNum = 0;
    
    	while(NULL!=curTask)
    	{
    		if(curTask->taskType==IO_TASK)
    			gettimeofday(&IOTaskStartTime,NULL);
    		else
    			gettimeofday(&computeTaskStartTime,NULL);
    		fpid=fork();
    		if(0==fpid)
    		{
    			parentProcess=0;
    			break;
    		}
    		else if(-1==fpid)
    		{
    			printf("Generate child Process error!\n");
    			exit(0);
    		}
    
    		wait(NULL);
    		
    		if(COMPUTE_TASK==curTask->taskType)
    			gettimeofday(&computeTaskEndTime,NULL);
    		else
    			gettimeofday(&IOTaskEndTime,NULL);
    		printf("Generate child process with pid:%d\n",fpid);
    
    		++childProcessNum;
    		curTask=curTask->next;
    
    	}
    
    	if(parentProcess==0)
    	{
    		if(curTask->taskType==IO_TASK)
    		{
    			executeIOTask();
    			printf("This is a IO task, pid:%d parent pid:%d\n",getpid(),getppid());//Print process ID and parent process ID
    		}
    		if(curTask->taskType==COMPUTE_TASK)
    		{
    			executeComputeTask();
    			printf("This is a compute task, pid:%d parent pid:%d\n",getpid(),getppid());//Print process ID and parent process ID
    		}
    	}
    	else
    	{
    		//Parent Process, we calculate the time for executing computing task and the time fo executing IO task
    		computeTaskTimeElapse = (double)(computeTaskEndTime.tv_sec - computeTaskStartTime.tv_sec)*1000.0+(double)(computeTaskEndTime.tv_usec - computeTaskStartTime.tv_usec)/1000.0;
    		IOTaskTimeElapse = (double)(IOTaskEndTime.tv_sec - IOTaskStartTime.tv_sec)*1000.0+(double)(IOTaskEndTime.tv_usec - IOTaskStartTime.tv_usec)/1000.0;
    		totalTimeElapse = (double)(computeTaskEndTime.tv_sec-IOTaskStartTime.tv_sec)*1000.0+(double)(computeTaskEndTime.tv_usec-IOTaskStartTime.tv_usec)/1000.0;
    		printf("Compute Task Time Consume:%fms, IO Task Time Consume: %fms, Total Time Consume:%fms \n", computeTaskTimeElapse,IOTaskTimeElapse,totalTimeElapse);
    	}
    
    
    }
    
    
    展开全文
  • Android 测试存储设备的读写速度

    千次阅读 2017-09-27 09:55:42
    使用Linux的dd命令可以很快捷的获取存储的读写速度。写入测试:for (int i = 0; i (); i++) { MyLog.i("USB.Write>Path:" + arrayFilePath.get(i)); if (new File(arrayFilePath.get(i)).e
  • TwinCAT ST编写的读写CSV文件功能
  • 主要介绍了C#实现提高xml读写速度的方法,并且针对各类文件的读写做了较为细致的分析,非常实用,需要的朋友可以参考下
  • 主要介绍了c#之FileStream对象读写文件,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • 关于Windows文件读写(提高读写速度)

    千次阅读 2011-11-16 15:59:33
    这几天在研究怎么才能加快windows文件读写速度,搜了很多文章,MSDN也看了不少。稍微给大家分享一下。 限制windows文件读写速度的瓶颈其实最终还是来源于我们硬盘的固有特性,磁盘本身的转速和硬盘的串行化工作...
  • VB读写文件测试,可以对比一下速度,了解一下VB的读写方式
  • linux挂载u盘并测试读写速度

    千次阅读 2019-05-10 14:17:29
    挂载u盘 1,将u盘插入机器,在目录/mnt下回出现一个sda 2,确定在 目录 /mnt 下建立了 文件夹 /usb,如果未建立可键入一下命令:mkdir /mnt/usb,...成功后,即可使用 u 盘了, 文件就在目录 /mnt/usb 下。 4,卸载u...
  • 如何查看手机内存速度?手机内存速度多少算正常?下面小编就给大家介绍下手机内存读取速度测试发方法!今早,手机内存问题再度引起热潮,很多朋友都在讨论手机内存速度问题。那么问题来了,如何正确测试自己手机内存...
  • 而且当某时刻磁盘读写并不频繁的时候,默认都使用 sleep,无疑是在白白浪费生命! 令牌桶? 此时我又想起了 nginx 限流使用的令牌桶,每个令牌能够处理一个请求,那我能不能每个令牌就读取指定量的数据呢?这样...
  • 基于c++的简易csv快速读写文件(.cpp),可对大型csv文件进行短时间的读写操作,使用时更改csv路径即可,注释栏内可用于计算操作完成时间
  • 前面介绍的文件读写函数都是顺序读写,即读写文件只能从头开始,依次读写各个数据。但在实际开发中经常需要读写文件的中间部分,要解决这个问题,就得先移动文件内部的位置指针,再进行读写。这种读写方式称为随机...
  • C语言文件读写操作(详解)

    万次阅读 多人点赞 2020-07-21 23:02:51
    进行C语言文件读写时,都会先进行“打开文件”操作,这个操作就是在打开数据流,而“关闭文件”操作就是关闭数据流。 缓冲区 在程序执行时,所提供的额外内存,可用来暂时存放准备执行的数据。它的设置是为了提高...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 282,535
精华内容 113,014
关键字:

文件读写速度