如何改进 Python C Extensions 文件行阅读?

Posted

技术标签:

【中文标题】如何改进 Python C Extensions 文件行阅读?【英文标题】:How to improve Python C Extensions file line reading? 【发布时间】:2019-05-22 15:17:29 【问题描述】:

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

我的目标是使用带有行缓存策略的 Python C 扩展实现我自己的 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 C 扩展代码打开文件并逐行读取的 Python 代码:

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

现在 Python C 扩展代码 fastfilepackage.FastFile 和 C++ 11 std::ifstream 需要 3 秒来解析 100MB 的日志数据,而 Python 实现需要 1 秒。

文件myfile 的内容只是log lines,每行大约100~300 个字符。这些字符只是 ASCII(模块 % 256),但由于记录器引擎上的错误,它可以放置无效的 ASCII 或 Unicode 字符。因此,这就是我在打开文件时使用errors='replace' 策略的原因。

我只是想知道是否可以替换或改进这个 Python C 扩展实现,减少运行 Python 程序的 3 秒时间。

我用它来做基准测试:

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 )

相关问题:

    Reading file Line By Line in C Improving C++'s reading file line by line?

【问题讨论】:

你的测试代码应该是if 'word' in iterable():,还是像以前一样是if 'word' in item:?正如所写,if 'word' in iterable(): 是荒谬的。 没关系;我检查了你的完整代码,现在它(有点)有意义。但是,以这种方式实现它会降低您的性能;我已经更新了my answer 来解决这个问题。 仅供参考,this is a memory leak waiting to happen。如果nextcall 没有完美配对,那么next 无法decref 它丢弃的行;在它们配对时避免泄漏只是因为call 最终返回了对字符串的拥有引用(这意味着您的缓存现在是借用的引用),因此pop_front 不会泄漏。如果你不止一次调用call,你会返回同一个指针两次,只有一个拥有引用,这将导致双重释放。 100MB 日志文件 á 每行 100-300 个字符导致大约 500K 行。这意味着大约 500K 次以零结尾的 C 字符串被转换为 Python Unicode 字符串,然后在 Python 中进行处理。如果性能是主要目标,那么在 C 中进行处理并仅将结果传递给 Python,或者完全在 Python 中执行处理可能会更好。假设这两种变体都应该比这种方法更快,调用原生 C 的次数为 500K。 @StephanSchlecht 我刚刚将 std::getline 与 Posix getline 进行了基准测试,std::getline 比 Python 内置 readline 慢 2.5 倍,而 Posix getline(在 msvc 上不可用)只有 1.5 倍比 Python 内置 getline 慢。在这些结果中,我排除了从 c string 到 Python Unicode 的转换。当启用从 c string 到 Python Unicode 的转换时,它只增加了 0.4 的减速,然后 std::getline 慢了 2.9,而 Posix getline 慢了 1.9。事实上,瓶颈更多的是使用的 getline 实现,而不是 Python 和 C 接口。 【参考方案1】:

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

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

虽然iostream 确实执行缓冲,但它只执行io.BufferedReader 的工作,而不是io.TextIOWrapperio.TextIOWrapper 添加了额外的缓冲层,从 BufferedReader 中读取 8 KB chunks 并将它们批量解码为 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,因为他们不能保证他们正在包装一个 BufferedReader),但这是重新实现您自己的方案的坚实基础。

更新:在检查您的完整代码(这与您发布的内容大不相同)时,您遇到了其他问题。您的tp_iternext 只是重复产生None,要求您调用您的对象来检索字符串。那真不幸。这比每个项目的 Python 解释器开销增加了一倍以上(tp_iternext 调用起来很便宜,非常专业;tp_call 并不是那么便宜,通过复杂的通用代码路径,需要解释器传递一个空的 tuple您从不使用的 args 等;旁注,PyFastFile_tp_call 应该接受 kwds 的第三个参数,您忽略它,但仍必须接受;转换为 ternaryfunc 正在消除错误,但这会在某些平台上中断)。

最后一点(除了最小的文件之外,与所有文件的性能无关):tp_iternext 的合同不要求您在迭代器耗尽时设置异常,只需您 return NULL;。您可以删除您对PyErr_SetNone( PyExc_StopIteration ); 的电话;只要没有设置其他异常,return NULL; 单独表示迭代结束,所以你可以通过不设置来节省一些工作。

【讨论】:

极小的性能提示:通常,C++ 模板不能专门用于实际函数,只能用于函数原型,这意味着函数最终通过指针调用,这比直接调用。仿函数(和 lambda,它们是仿函数的语法糖)是独特的类型,并且模板完全专门针对它们。将(self->cppobjectpointer)->call( PyUnicode_DecodeUTF8 ); 之类的代码更改为(self->cppobjectpointer)->call( [](const char *s, Py_ssize_t sz, const char *e) return PyUnicode_DecodeUTF8(s, sz, e); ); 可能会有所收获 tp_call 并不便宜,通过复杂的通用代码路径,我使用call(),因为它比简单的object.function() 调用更优化。但是现在,我停止从tp_next 返回 None ,实际上我正在返回第一个对象。谢谢!【参考方案2】:

这些结果仅适用于 Linux 或 Cygwin 编译器。如果您使用 Visual Studio Compilerstd::getlinestd::ifstream.getline 的结果是 100% 或比 Python 内置的 for line in file 迭代器慢。

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

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

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

PyObject* emtpycacheobject;
emtpycacheobject = PyUnicode_DecodeUTF8( "", 0, "replace" );

我设法优化了我的 Posix C getline 使用(通过缓存总缓冲区大小而不是总是传递 0),现在 Posix C getline 比 Python 内置 for line in file 优于 5%。我想如果我删除 Posix C getline 周围的所有 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;

我还设法通过使用 std::ifstream.getline() 将 C++ 性能提高到仅比内置 Python C for line in file20%

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();

最后,通过缓存它用作输入的std::string,我还设法使10% 的性能比带有std::getline 的内置Python C for line in file 慢:

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();

从 C++ 中删除所有样板后,Posix C getline 的性能比 Python 内置 for line in file 低 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;

上次测试运行的值,其中 Posix C getline 比 Python 差 10%:

$ /bin/python3.6 fastfileperformance.py fastfile_time 1.15%, python_time 0.87%
Python   timedifference 0:00:00.695292
FastFile timedifference 0:00:00.796305

$ /bin/python3.6 fastfileperformance.py fastfile_time 1.13%, python_time 0.88%
Python   timedifference 0:00:00.708298
FastFile timedifference 0:00:00.803594

$ /bin/python3.6 fastfileperformance.py fastfile_time 1.14%, python_time 0.88%
Python   timedifference 0:00:00.699614
FastFile timedifference 0:00:00.795259

$ /bin/python3.6 fastfileperformance.py fastfile_time 1.15%, python_time 0.87%
Python   timedifference 0:00:00.699585
FastFile timedifference 0:00:00.802173

$ /bin/python3.6 fastfileperformance.py fastfile_time 1.15%, python_time 0.87%
Python   timedifference 0:00:00.703085
FastFile timedifference 0:00:00.807528

$ /bin/python3.6 fastfileperformance.py fastfile_time 1.17%, python_time 0.85%
Python   timedifference 0:00:00.677507
FastFile timedifference 0:00:00.794591

$ /bin/python3.6 fastfileperformance.py fastfile_time 1.20%, python_time 0.83%
Python   timedifference 0:00:00.670492
FastFile timedifference 0:00:00.804689

【讨论】:

以上是关于如何改进 Python C Extensions 文件行阅读?的主要内容,如果未能解决你的问题,请参考以下文章

什么是 C++11 扩展 [-Wc++11-extensions]

VSCode如何进行插件迁移

小甲鱼Python视频第004讲:(改进我们的小游戏)课后习题及参考答案

如何改进此 Python 代码以提高效率?

如何改进 Python 中列表的模式匹配

如何利用python使用libsvm