衡量java.io.InputStream的性能 [英] Measuring performance of java.io.InputStream

查看：96 发布时间：2020/4/25 7:38:19 java performance io jvm inputstream

本文介绍了衡量java.io.InputStream的性能的处理方法，对大家解决问题具有一定的参考价值，需要的朋友们下面随着小编来一起学习吧！

问题描述

我有一个5GB的文件，我想按块读取，例如2MB.使用java.io.InputStream可以正常工作.因此，我对这件事进行了如下测量:

I have a file 5GB in size which I want to read by chunks, say 2MB. Using java.io.InputStream works fine. So I measured this thing as follows:

static final byte[] buffer = new byte[2 * 1024 * 1024];

public static void main(String args[]) throws IOException {
    while(true){
        InputStream is = new FileInputStream("/tmp/log_test.log");
        long bytesRead = 0;
        int readCurrent;
        long start = System.nanoTime();
        while((readCurrent = is.read(buffer)) > 0){
            bytesRead += readCurrent;
        }
        long end = System.nanoTime();
        System.out.println(
            "Bytes read = " + bytesRead + ". Time elapsed = " + (end - start)
        );
    }
}

结果= 2121714428

RESULT = 2121714428

可以看出，平均需要2121714428纳米.之所以如此，是因为该实现会将(*env)->SetByteArrayRegion(env, bytes, off, nread, (jbyte *)buf);的数据读入malloc ed或堆栈分配的缓冲区中，如

It can be seen that averagely it takes 2121714428 nanos. It is so because the implementation does (*env)->SetByteArrayRegion(env, bytes, off, nread, (jbyte *)buf); of the data read into a malloced or stack allocated buffer as shown here. So memcpy takes pretty large amount of CPU time:

由于JNI规范定义了

在关键区域内，本机代码不得调用其他JNI 函数或任何可能导致当前线程执行的系统调用阻塞并等待另一个Java线程. (例如，当前线程不得在另一个Java编写的流上调用read 线程.)

Inside a critical region, native code must not call other JNI functions, or any system call that may cause the current thread to block and wait for another Java thread. (For example, the current thread must not call read on a stream being written by another Java thread.)

在关键部分的 常规文件 中，我看不到有任何问题.从常规文件读取仅被短暂阻止，并且不依赖于任何Java线程.像这样:

I don't see any problems to do read from a regular file within a critical section. Reading from a regular file is blocked only briefly and does not depend on any java thread. Something like this:

static final byte[] buffer = new byte[2 * 1024 * 1024];

public static void main(String args[]) throws IOException {
    while (true) {
        int fd = open("/tmp/log_test.log");
        long bytesRead = 0;
        int readCurrent;
        long start = System.nanoTime();
        while ((readCurrent = read(fd, buffer)) > 0) {
            bytesRead += readCurrent;
        }
        long end = System.nanoTime();
        System.out.println("Bytes read = " + bytesRead + ". Time elapsed = " + (end - start));
    }
}

private static native int open(String path);

private static native int read(int fd, byte[] buf);

JNI函数:

JNIEXPORT jint JNICALL Java_com_test_Main_open
  (JNIEnv *env, jclass jc, jstring path){
    const char *native_path = (*env)->GetStringUTFChars(env, path, NULL);
    int fd = open(native_path, O_RDONLY);
    (*env)->ReleaseStringUTFChars(env, path, native_path);
    return fd;
}


JNIEXPORT jint JNICALL Java_com_test_Main_read
  (JNIEnv *env, jclass jc, jint fd, jbyteArray arr){
    size_t java_array_size = (size_t) (*env)->GetArrayLength(env, arr);
    void *buf = (*env)->GetPrimitiveArrayCritical(env, arr, NULL);
    ssize_t bytes_read = read(fd, buf, java_array_size);
    (*env)->ReleasePrimitiveArrayCritical(env, arr, buf, 0);
    return (jint) bytes_read;
}

结果= 1179852225

RESULT = 1179852225

以循环方式运行此程序平均需要1179852225纳米，这几乎是效率的两倍.

Runnning this in a loop it takes averagely 1179852225 nanos which is almost twice more efficient.

问题: 从关键区域中的 常规文件 中读取数据的实际问题是什么?

Question: What's the actual problem with reading from a regular file within critical section?

衡量java.io.InputStream的性能 [英] Measuring performance of java.io.InputStream

问题描述

推荐答案

相关文章

Java开发最新文章

热门教程

热门工具

登录关闭

衡量java.io.InputStream的性能 [英] Measuring performance of java.io.InputStream

问题描述

推荐答案

相关文章

Java开发最新文章

热门教程

热门工具

登录 关闭

登录关闭