Question

最初是在Are there alternative and portable algorithm implementation for reading lines from a file on Windows (Visual Studio Compiler) and Linux?上提出的，但由于在国外也关闭，因此，我在这里尝试通过更简洁的案例用法来缩小其范围。

我的目标是使用带有行缓存策略的Python C Extensions为Python实现我自己的文件读取模块。没有任何行缓存策略的纯Python算法实现是这样的：

# This takes 1 second to parse 100MB of log data
with open('myfile', 'r', errors='replace') as myfile:
    for line in myfile:
        if 'word' in line: 
            pass

恢复Python C扩展的实现：（see here the full code with line caching policy）

// other code to open the file on the std::ifstream object and create the iterator
...

static PyObject * PyFastFile_iternext(PyFastFile* self, PyObject* args)
{
    std::string newline;

    if( std::getline( self->fileifstream, newline ) ) {
        return PyUnicode_DecodeUTF8( newline.c_str(), newline.size(), "replace" );
    }

    PyErr_SetNone( PyExc_StopIteration );
    return NULL;
}

static PyTypeObject PyFastFileType =
{
    PyVarObject_HEAD_INIT( NULL, 0 )
    "fastfilepackage.FastFile" /* tp_name */
};

// create the module
PyMODINIT_FUNC PyInit_fastfilepackage(void)
{
    PyFastFileType.tp_iternext = (iternextfunc) PyFastFile_iternext;
    Py_INCREF( &PyFastFileType );

    PyObject* thismodule;
    // other module code creating the iterator and context manager
    ...

    PyModule_AddObject( thismodule, "FastFile", (PyObject *) &PyFastFileType );
    return thismodule;
}

这是Python代码，它使用Python C扩展代码打开一个文件并逐行读取其行：

from fastfilepackage import FastFile

# This takes 3 seconds to parse 100MB of log data
iterable = fastfilepackage.FastFile( 'myfile' )
for item in iterable:
    if 'word' in iterable():
        pass

现在，带有C ++ 11 fastfilepackage.FastFile的Python C扩展代码std::ifstream花费3秒来解析100MB的日志数据，而提供的Python实现花费1秒。

文件myfile的内容仅为log lines，每行大约100至300个字符。字符只是ASCII码（模块％256），但是由于记录器引擎上的错误，它可以放置无效的ASCII或Unicode字符。因此，这就是为什么我在打开文件时使用errors='replace'策略的原因。

我只是想知道我是否可以替换或改进此Python C Extension实现，从而减少3秒钟的时间来运行Python程序。

我用它来做基准测试：

import time
import datetime
import fastfilepackage

# usually a file with 100MB
testfile = './myfile.log'

timenow = time.time()
with open( testfile, 'r', errors='replace' ) as myfile:
    for item in myfile:
        if None:
            var = item

python_time = time.time() - timenow
timedifference = datetime.timedelta( seconds=python_time )
print( 'Python   timedifference', timedifference, flush=True )
# prints about 3 seconds

timenow = time.time()
iterable = fastfilepackage.FastFile( testfile )
for item in iterable:
    if None:
        var = iterable()

fastfile_time = time.time() - timenow
timedifference = datetime.timedelta( seconds=fastfile_time )
print( 'FastFile timedifference', timedifference, flush=True )
# prints about 1 second

print( 'fastfile_time %.2f%%, python_time %.2f%%' % ( 
        fastfile_time/python_time, python_time/fastfile_time ), flush=True )

相关问题：

Answer 1

逐行阅读将导致不可避免的减速。 Python的内置的面向文本的只读文件对象实际上是三层：

io.FileIO-对文件的原始无缓冲访问
io.BufferedReader-缓冲基础的FileIO
io.TextIOWrapper-包装BufferedReader以实现对str的缓冲解码

虽然iostream确实执行了缓冲，但是它只是在执行io.BufferedReader，而不是io.TextIOWrapper。 io.TextIOWrapper添加了额外的缓冲层，从BufferedReader中读取8 KB 块并将其批量解码为str（当块以不完整的结尾时）字符，它将保存剩余字节以保留到下一个块之前），然后根据请求从解码的块中产生单独的行，直到用完为止（当解码的块以部分行结尾时，其余的部分将保留到下一个解码的块中）

相反，您使用std::getline一次占用一行，然后使用PyUnicode_DecodeUTF8一次解码一行，然后返回给调用者；到调用者请求下一行时，赔率是至少与tp_iternext实现相关联的某些代码已离开CPU高速缓存（或至少离开了最快的部分）。紧密循环将8 KB文本解码为UTF-8将会非常快。反复离开循环，一次只解码100-300字节会更慢。

解决方案是大致执行io.TextIOWrapper的操作：读取块而不是行，然后批量解码（保留下一个块的不完整UTF-8编码字符），然后搜索换行符解码缓冲区中的子字符串，直到耗尽为止（不要每次都修剪缓冲区，只跟踪索引）。当解码缓冲区中没有剩余的完整行时，请修剪已产生的内容，然后读取，解码并追加新的块。

Python's underlying implementation of io.TextIOWrapper.readline上还有一些改进的空间（例如，每次读取块并间接调用时，他们必须构造一个Python级别int，因为他们不能保证自己包装了{ {1}}），但这是重新实现自己的方案的坚实基础。

更新：在检查完整代码（与您发布的代码完全不同）时，您还遇到了其他问题。您的BufferedReader只是反复产生tp_iternext，要求您调用对象以检索字符串。那真不幸。这比将每个项目的Python解释器开销增加一倍还多（None调用便宜，相当专业； tp_iternext并不太便宜，要经过复杂的通用代码路径，需要解释器传递一个空的tp_call中您从未使用过的args等；旁注，tuple应该接受PyFastFile_tp_call的第三个参数，您可以忽略它，但仍然必须接受；将其转换为kwds使错误消失，但这在某些平台上会中断。

最后的注释（除最小的文件外，与所有文件的性能都没有真正的关系）：ternaryfunc的合同不需要您在迭代器用尽时设置例外，只需要tp_iternext。您可以删除对return NULL;的呼叫；只要没有设置其他异常，PyErr_SetNone( PyExc_StopIteration );就单独表示迭代结束，因此您可以通过根本不设置来节省一些工作。

Answer 2

这些结果仅适用于Linux或Cygwin编译器。如果您使用的是container-runtime c-r c-r | | | init VS web app / \ web app，则Visual Studio Compiler和std::getline的结果比Python内置的std::ifstream.getline迭代器慢100%。

您将看到for line in file被用在代码周围，因为这样，我仅对读取行所用的时间进行基准测试，不包括Python将输入字符串转换成Python Unicode对象所花费的时间。因此，我注释掉了所有调用linecache.push_back( emtpycacheobject )的行。

这些是示例中使用的全局定义：

PyUnicode_DecodeUTF8

我设法优化了Posix C const char* filepath = "./myfile.log"; size_t linecachesize = 131072; PyObject* emtpycacheobject; emtpycacheobject = PyUnicode_DecodeUTF8( "", 0, "replace" );的使用（通过缓存总缓冲区大小而不是始终传递0），现在Posix C getline击败了getline内置的Python { {1}}。我猜想如果我删除Posix C for line in file周围的所有Python和C ++代码，它将获得更多性能：

5%

通过使用getline，我还设法将C ++性能提高到仅比内置Python C char* readline = (char*) malloc( linecachesize ); FILE* cfilestream = fopen( filepath, "r" ); if( cfilestream == NULL ) { std::cerr << "ERROR: Failed to open the file '" << filepath << "'!" << std::endl; } if( readline == NULL ) { std::cerr << "ERROR: Failed to alocate internal line buffer!" << std::endl; } bool getline() { ssize_t charsread; if( ( charsread = getline( &readline, &linecachesize, cfilestream ) ) != -1 ) { fileobj.getline( readline, linecachesize ); // PyObject* pythonobject = PyUnicode_DecodeUTF8( readline, charsread, "replace" ); // linecache.push_back( pythonobject ); // return true; Py_XINCREF( emtpycacheobject ); linecache.push_back( emtpycacheobject ); return true; } return false; } if( readline ) { free( readline ); readline = NULL; } if( cfilestream != NULL) { fclose( cfilestream ); cfilestream = NULL; }慢20%：

for line in file

最后，我还通过缓存用作输入的std::ifstream.getline()，仅比内置char* readline = (char*) malloc( linecachesize ); std::ifstream fileobj; fileobj.open( filepath ); if( fileobj.fail() ) { std::cerr << "ERROR: Failed to open the file '" << filepath << "'!" << std::endl; } if( readline == NULL ) { std::cerr << "ERROR: Failed to alocate internal line buffer!" << std::endl; } bool getline() { if( !fileobj.eof() ) { fileobj.getline( readline, linecachesize ); // PyObject* pyobj = PyUnicode_DecodeUTF8( readline, fileobj.gcount(), "replace" ); // linecache.push_back( pyobj ); // return true; Py_XINCREF( emtpycacheobject ); linecache.push_back( emtpycacheobject ); return true; } return false; } if( readline ) { free( readline ); readline = NULL; } if( fileobj.is_open() ) { fileobj.close(); }的内置Python C 10%慢了for line in file个性能：

std::getline

从C ++中删除所有样板之后，Posix C std::string的性能比Python内置std::string line; std::ifstream fileobj; fileobj.open( filepath ); if( fileobj.fail() ) { std::cerr << "ERROR: Failed to open the file '" << filepath << "'!" << std::endl; } try { line.reserve( linecachesize ); } catch( std::exception error ) { std::cerr << "ERROR: Failed to alocate internal line buffer!" << std::endl; } bool getline() { if( std::getline( fileobj, line ) ) { // PyObject* pyobj = PyUnicode_DecodeUTF8( line.c_str(), line.size(), "replace" ); // linecache.push_back( pyobj ); // return true; Py_XINCREF( emtpycacheobject ); linecache.push_back( emtpycacheobject ); return true; } return false; } if( fileobj.is_open() ) { fileobj.close(); }低10％：

getline

上次测试运行的值（其中Posix C for line in file比Python低10％）

const char* filepath = "./myfile.log";
size_t linecachesize = 131072;

PyObject* emtpycacheobject = PyUnicode_DecodeUTF8( "", 0, "replace" );
char* readline = (char*) malloc( linecachesize );
FILE* cfilestream = fopen( filepath, "r" );

static PyObject* PyFastFile_tp_call(PyFastFile* self, PyObject* args, PyObject *kwargs) {
    Py_XINCREF( emtpycacheobject );
    return emtpycacheobject;
}

static PyObject* PyFastFile_iternext(PyFastFile* self, PyObject* args) {
    ssize_t charsread;
    if( ( charsread = getline( &readline, &linecachesize, cfilestream ) ) == -1 ) {
        return NULL;
    }
    Py_XINCREF( emtpycacheobject );
    return emtpycacheobject;
}

static PyObject* PyFastFile_getlines(PyFastFile* self, PyObject* args) {
    Py_XINCREF( emtpycacheobject );
    return emtpycacheobject;
}

static PyObject* PyFastFile_resetlines(PyFastFile* self, PyObject* args) {
    Py_INCREF( Py_None );
    return Py_None;
}

static PyObject* PyFastFile_close(PyFastFile* self, PyObject* args) {
    Py_INCREF( Py_None );
    return Py_None;
}

如何提高Python C Extensions文件行的读取？

2 个答案: