C 比 Java 慢：为什么？

Question

我很快写了一个 C 程序来提取一组 gzipped 文件（包含大约 500,000 行）的 i-th line。这是我的 C 程序：

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <errno.h>
#include <zlib.h>

/* compilation:
gcc  -o linesbyindex -Wall -O3 linesbyindex.c -lz
*/
#define MY_BUFFER_SIZE 10000000
static void extract(long int index,const char* filename)
   {
   char buffer[MY_BUFFER_SIZE];
   long int curr=1;
   gzFile in=gzopen (filename, "rb");
   if(in==NULL)
       {
       fprintf(stderr,"Cannot open \"%s\" %s.\n",filename,strerror(errno));
       exit(EXIT_FAILURE);              }
   while(gzread(in,buffer,MY_BUFFER_SIZE)!=-1 && curr<=index)
       {
       char* p=buffer;
       while(*p!=0)
           {
           if(curr==index)
               {
               fputc(*p,stdout);
               }
           if(*p=='\n')
               {
               ++curr;
               if(curr>index) break;
               }
           p++;
           }
       }
   gzclose(in);
   if(curr<index)
       {
       fprintf(stderr,"Not enough lines in %s (%ld)\n",filename,curr);
       }
   }

int main(int argc,char** argv)
   {
   int optind=2;
   char* p2;
   long int count=0;
   if(argc<3)
       {
       fprintf(stderr,"Usage: %s (count) files...\n",argv[0]);
       return EXIT_FAILURE;
       }
   count=strtol(argv[1],&p2,10);
   if(count<1 || *p2!=0)
       {
       fprintf(stderr,"bad number %s\n",argv[1]);
       return EXIT_SUCCESS;
       }
   while(optind< argc)
       {
       extract(count,argv[optind]);
       ++optind;
       }
   return EXIT_SUCCESS;
   } 

作为测试，我在java中写了以下等效代码：

import java.io.*;
import java.util.zip.GZIPInputStream;

public class GetLineByIndex{
   private int index;

   public GetLineByIndex(int count){
       this.index=count;
   }

   private String extract(File file) throws IOException
       {
       long curr=1;
       byte buffer[]=new byte[2048];
       StringBuilder line=null;
       InputStream in=null;
       if(file.getName().toLowerCase().endsWith(".gz")){
           in= (new GZIPInputStream(new FileInputStream(file)));
       }else{
           in= (new FileInputStream(file));
       }
             int nRead=0;
       while((nRead=in.read(buffer))!=-1)
           {
           int i=0;
           while(i<nRead)
               {
               if(buffer[i]=='\n')
                   {
                   ++curr;
                   if(curr>this.index) break;
                                     }
               else if(curr==this.index)
                   {
                   if(line==null) line=new StringBuilder(500);
                   line.append((char)buffer[i]);
                   }
               i++;
               }
           if(curr>this.index) break;
           }
       in.close();
       return (line==null?null:line.toString());
       }

   public static void main(String args[]) throws Exception{
       int optind=1;
       if(args.length<2){
           System.err.println("Usage: program (count) files...\n");
           return;
       }
       GetLineByIndex app=new GetLineByIndex(Integer.parseInt(args[0]));

       while(optind < args.length)
           {
           String line=app.extract(new File(args[optind]));
           if(line==null)
               {
               System.err.println("Not enough lines in "+args[optind]);
               }
           else
               {
               System.out.println(line);
               }
           ++optind;
           }
       return;
   }
} 

在同一台机器上，Java 程序（~1'45''）获取大索引比 C 程序（~2'15''）快得多（我多次运行该测试）。

我该如何解释这种差异？

Answer 1

Java 版本比 C 版本快的最可能的解释是 C 版本不正确。

修复 C 版本后，我得到了以下结果（与您声称 Java 比 C 更快的说法相矛盾）：

Java 1.7 -client: 65 milliseconds (after JVM warmed up)
Java 1.7 -server: 82 milliseconds (after JVM warmed up)
gcc -O3:          37 milliseconds

任务是打印文件 words.gz 中的第 200000 行。文件words.gz 是通过压缩/usr/share/dict/words 生成的。

---

...
static char buffer[MY_BUFFER_SIZE];
...
ssize_t len;
while((len=gzread(in,buffer,MY_BUFFER_SIZE)) > 0  &&  curr<=index)
    {
    char* p=buffer;
    char* endp=buffer+len;
    while(p < endp)
       {
...

Answer 2

因为 fputc() 不是很快，而且您在输出文件中逐个字符地添加 stuf。

调用 fputc_unlocked 或者更确切地说分隔您要添加的内容并调用 fwrite() 应该更快。

Answer 3

您的程序正在做不同的事情。我没有分析您的程序，但通过查看您的代码，我怀疑这种差异：

为了构建这条线，你在 Java 中使用它：

if(curr==this.index)
{
    if(line==null) line=new StringBuilder(500);
    line.append((char)buffer[i]);
}

这在 C 中：

if(curr==index)
{
    fputc(*p,stdout);
}

即您一次打印一个字符到标准输出。默认情况下是 buffere，但我怀疑它仍然比您在 Java 中使用的 500 个字符的缓冲区慢。

Answer 4

我对编译器执行哪些优化没有更深入的了解，但我猜这就是你的程序之间的区别所在。像这样的微基准测试非常、非常、非常难以正确和有意义。这是 Brian Goetz 的一篇文章，对此进行了详细说明：http://www.ibm.com/developerworks/java/library/j-jtp02225/index.html

Answer 5

非常大的缓冲区可能会更慢。我建议您使缓冲区大小相同。即 2 或 8 KB