内容


可爱的 Python

Pyrex 扩展并加速 Python 应用程序

对于适当类型的函数,Pyrex 可以给您超值回报

Comments

系列内容:

此内容是该系列 # 部分中的第 # 部分: 可爱的 Python

敬请期待该系列的后续内容。

此内容是该系列的一部分:可爱的 Python

敬请期待该系列的后续内容。

Pyrex 是一种专门设计用来编写 Python 扩展模块的语言。根据 Pyrex Web 站点的介绍,“它被设计用来在友好易用的高级 Python 世界和凌乱的低级 C 世界之间搭建一个桥梁。”虽然几乎所有的 Python 代码都可以作为有效的 Pyrex 代码使用,但是您可以在 Pyrex 代码中添加可选的静态类型声明,从而使得这些声明过的对象以 C 语言的速度运行。

加速 Python

从某种意义上来说,Pyrex 只是不断发展的 Python 类语言系列的一个部分:Jython、IronPython、Prothon、Boo、Vyper(现在没人用了)、Stackless Python(以一种方式)或 Parrot runtime(以另外一种方式)。按照语言的术语来说,Pyrex 本质上是在 Python 中添加了类型声明。它的另外几个变化没有这么重要(不过对 for 循环的扩展很漂亮)。

然而,您真正希望使用 Pyrex 的原因是它编写的模块比纯 Python 运行得更快,可能会快很多。

实际上,Pyrex 会从 Pyrex 代码生成一个 C 程序。中间文件 module.c 依然可以用于手工处理。然而对于“普通的” Pyrex 用户来说,没有什么理由需要修改所生成的 C 模块。Pyrex 本身可以让您访问那些对速度至关重要的 C 级代码,而节省了编写内存分配、回收、指针运算、函数原型等的工作。Pyrex 还可以无缝地处理 Python 级对象的所有接口;通常它都是通过在必要的地方将变量声明为 PyObject 结构并使用 Python C-API 调用进行内存处理和类型转换而实现的。

对于大部分情况来说,Pyrex 不需要不断对简单数据类型变量进行装箱(box)拆箱(unbox) 操作,因此速度比 Python 更快。例如,Python 中的 int 类型是一个具有很多方法的对象。它有一个继承树,自己有一个计算好的“方法解析顺序(mothod resolution order,MRO)”。它有分配和回收方法可以用于内存处理。它知道何时将自己转换为一个 long 类型,以及如何对其他类型的值进行数值运算。所有这些额外的功能都意味着在使用 int 对象进行处理时需要经过更多级的间接处理或条件检查。另外一方面,C 或 Pyrex 的 int 变量只是内存中各个位设置为 1 或 0 的一个区域。使用 C/Pyrex 的 int 类型进行处理不需要涉及 任何 间接操作或条件检查。一个 CPU “加”操作在硅芯片中就可以执行完了。

在仔细选择的情况中,Pyrex 模块的速度可以比 Python 版本的相同模块的运行速度快 40 到 50 倍。但是与使用 C 本身 编写的模块相比,Pyrex 版本的模块几乎都不会比 Python 版本的模块更长,代码更类似于 Python,而不是 C。

当然,当您开始谈论加速(类)Python 模块时,Pyrex 并不是惟一可用的工具。在 Python 开发者的选择中,也可以使用 Psyco。Psyco 可以保持代码非常简短;它是(x86)机器代码中的一个 JIT Python 代码编译器。与 Pyrex 不同,Psyco 并不会精确地限定变量的类型,而是根据数据 可能 是哪种类型的每种假设为每个 Python 代码块创建几种可能的机器代码。如果在一个给定的代码段中数据是是简单类型,例如 int,那么这段代码(如果是一个循环,这种情况就更为突出)就可以很快地运行。例如,x 在一个执行一百万次的循环中可以是 int 类型,但是在循环结束时可以依然是一个 float 类型的值。Psyco 可以使用与在 Pyrex 中显式指定的类型相同的类型来加速循环。

虽然 Pyrex 也并不难,但是 Psyco 更加简单易用。使用 Psyco 不过是在模块的末尾加上几行;实际上,如果加上正确的代码,那么即使在 Psyco 不可用时,模块也可以同样运行(只是速度较慢)。

清单 1. 只有在 Psyco 可用时才使用 Psyco
# Import Psyco if available
try:
    import psyco
    psyco.full()
except ImportError:
    pass

要使用 Pyrex,需要对代码进行的修改会更多(但也不过是多一点而已),系统中还需要安装一个 C 编译器,并正确对生成 Pyrex 模块的系统进行配置。虽然您 可以 分发二进制的 Pyrex 模块,但是为了能使您的模块在其他地方也可以运行,Python 的版本、架构和终端用户需要的优化选项必须匹配。

速度初体验

我最近为 developerWorks 的文章 Beat spam using hashcash 创建了一个纯 Python 的 hashcash 实现,但是基本上来说,hashcash 是一种使用 SHA-1 提供 CPU 工作的技术。Python 有一个标准的模块 sha,这使得编写 hashcash 非常简单。

与我编写的 95% 的 Python 程序不同,hashcash 模块缓慢的速度让我心烦,至少有那么一点点心烦。按照设计,这个协议就是要吃光所有的 CPU 周期,因此运行效率非常关键。hashcash.c 的 ANSI C 二进制文件运行的速度是这个 hashcash.py 脚本的 10 倍。而且启用了 PPC/Altivec 的优化后的 hashcash.c 二进制文件的速度是普通的 ANSI C 版本的 4 倍(1Ghz 的 G4/Altivec 在处理 hashcash/SHA 操作时的速度相当于 3Ghz 的 Pentium4™/MMX;G5 的速度会更快)。因此在我的 TiPowerbook 上的测试显示,这个模块的速度比优化后的 C 版本速度慢 40 倍(不过在 x86 上的差距没有这么大)。

由于这个模块的运行速度很慢,可能 Pyrex 会是一个比较好的加速方法。至少我认为是如此。“Pyrex 化” hashcash.py 的第一件事情(当然是在安装 Pyrex 之后)是简单地将其拷贝为 hashcash_pyx.pyx,并试图这样处理:

$ pyrexc hashcash_pyx.pyx

创建二进制模块

运行这个命令会生成一个 hashcash.c 文件(这会对源文件进行一些微小的改动)。不幸的是,调整 gcc 开关刚好适合我的平台需要点技巧,因此我决定采用推荐的捷径,让 distutils 为我做一些工作。标准的 Python 安装知道如何在模块安装过程中使用本地的 C 编译器,以及如何使用 distutils 来简化 Pyrex 模块的共享。我创建了一个 setup_hashcash.py 脚本,如下所示:

清单 2. setup_hashcash.py 脚本
from distutils.core import setup
from distutils.extension import Extension
from Pyrex.Distutils import build_ext
setup(
  name = "hashcash_pyx",
  ext_modules=[
    Extension("hashcash_pyx", ["hashcash_pyx.pyx"], libraries = [])
    ],
  cmdclass = {'build_ext': build_ext}
)

运行下面的命令,完整地编译一个基于 C 的扩展模块 hashcash

$ python2.3 prime_setup.py build_ext --inplace

代码修改

我把从 hashcash.pyx 生成基于 C 的模块的工作有些简化了。实际上,我需要对源代码进行两处修改;通过查找 pyrexc 抱怨的位置来找到要修改的位置。在代码中,我使用了一个不支持的列表,将其放入一个普通的 for 循环。这非常简单。我还将增量赋值从 counter+=1 修改为 counter=counter+1

就这么多了。这就是我的第一个 Pyrex 模块。

测试速度

为了可以简单地测试要开发的模块的速度提高情况,我编写了一个简单的测试程序来运行不同版本的模块:

清单 3. 测试程序 hashcash_test.py
#!/usr/bin/env python2.3
import time, sys, optparse
hashcash = __import__(sys.argv[1])
start = time.time()
print hashcash.mint('mertz@gnosis.cx', bits=20)
timer = time.time()-start
sys.stderr.write("%0.4f seconds (%d hashes per second)\n" %
        (timer, hashcash.tries[0]/timer))

令人兴奋的是,我决定来看一下只通过 Pyrex 编译可以怎样提高速度。注意在下面所有的例子中,真实的时间变化很大,都是随机的。我们要看的内容是“hashes per second”,它可以精确可靠地测量速度。因此比较一下纯粹的 Python 和 Pyrex:

清单 4. 纯 Python 和 “纯 Pyrex”的比较
$ ./hashcash_test.py hashcash
1:20:041003:mertz@gnosis.cx::I+lyNUpV:167dca
13.7879 seconds (106904 hashes per second)
$ ./hashcash_test.py hashcash_pyx > /dev/null
6.0695 seconds (89239 hashes per second)

噢!使用 Pyrex 几乎慢了 20%。这并不是我期望的。现在应该来分析一下代码可能加速的地方了。下面这个简短的函数会试图消耗所有的时间:

清单 5. hashcash.py 中的函数
def _mint(challenge, bits):
    "Answer a 'generalized hashcash' challenge'"
    counter = 0
    hex_digits = int(ceil(bits/4.))
    zeros = '0'*hex_digits
    hash = sha
    while 1:
        digest = hash(challenge+hex(counter)[2:]).hexdigest()
        if digest[:hex_digits] == zeros:
            tries[0] = counter
            return hex(counter)[2:]
        counter += 1

我需要利用 Pyrex 变量声明的优点来进行加速。有些变量显然是整数,另外一些变量显然是字符串 —— 我们可以指定这些类型。在进行修改时,我将使用 Pyrex 的经过改进的 for 循环:

清单 6. 经过最低限度 Pyrex 改进的 mint 函数
cdef _mint(challenge, int bits):
    # Answer a 'generalized hashcash' challenge'"
    cdef int counter, hex_digits, i
    cdef char *digest
    hex_digits = int(ceil(bits/4.))
    hash = sha
    for counter from 0 <= counter < sys.maxint:
        py_digest = hash(challenge+hex(counter)[2:]).hexdigest()
        digest = py_digest
        for i from 0 <= i < hex_digits:
            if digest[i] != c'0': break
        else:
            tries[0] = counter
            return hex(counter)[2:]

到现在为止一切都非常简单。我只声明了早已知道的一些变量类型,并使用最干净的 Pyrex counter 循环。一个小技巧是将 py_digest(一个 Python 字符串)赋值给 digest(一个 C/Pyrex 字符串),目的是确定其类型。经过实验,我还发现循环字符串比较操作速度都非常快。这些会带来什么好处呢?

清单 7. Pyrex 化 mint 函数的速度结果
$ ./hashcash_test.py hashcash_pyx2 >/dev/null
20.3749 seconds (116636 hashes per second)

这下好多了。我已经对原有的 Python 进行了一些细微的改进,这可以稍微提高最初的 Pyrex 模块的速度。不过效果还不明显,仅仅提高了很少的百分比。

剖析

有些东西似乎不对。速度提高几个百分比和 Pyrex 主页(以及很多 Pyrex 用户)那样提高 40 倍有很大的差距。现在应该来看一下 这个 Python _mint() 函数中 哪些 地方真正消耗了时间。有一个 quick 脚本(此处没有给出)可以分解复杂操作 sha(challenge+hex(counter)[2:]).hexdigest()

清单 8. hashcash 的 mint 函数的时间消耗
1000000 empty loops:     0.559
------------------------------
1000000 sha()s:          2.332
1000000 hex()[2:]s:      3.151
   just hex()s:         <2.471>
1000000 concatenations:  0.855
1000000 hexdigest()s:    3.742
------------------------------
Total:                  10.079

显然,我并不能将这个循环从 _mint() 函数中删除。虽然 Pyrex 改进后的 for 循环可能有一点加速,但是整个函数主要是一个循环。我也不能删除对 sha() 的调用,除非要使用 Pyrex 重新实现 SHA-1(即使我要这样做,也没有自信自己可以比 Python 标准的 sha 模块的作者做得更好)。而且,如果我希望得到一个 sha.SHA 对象的 hash 值,就只能调用 .hexdigest().digest();前者的速度更快。

现在真正要解决的是 hex() 对 counter 变量的转换,以及结果中时间片的消耗情况。我可能需要使用 Pyrex/C 的字符串连接操作,而不是 Python 的字符串对象。然而,我见过的惟一一种避免 hex() 转换的方法是手工在嵌套循环之外构建一个后缀。虽然这样做可以避免 int 到 char 类型的转换,但是需要生成更多代码:

清单 9. 完全 Pyrex 优化过的 mint 函数
cdef _mint(char *challenge, int bits):
    cdef int hex_digits, i0, i1, i2, i3, i4, i5
    cdef char *ab, *digest, *trial, *suffix
    suffix = '******'
    ab = alphabet
    hex_digits = int(ceil(bits/4.))
    hash = sha
    for i0 from 0 <= i0 < 55:
        suffix[0] = ab[i0]
        for i1 from 0 <= i1 < 55:
            suffix[1] = ab[i1]
            for i2 from 0 <= i2 < 55:
                suffix[2] = ab[i2]
                for i3 from 0 <= i3 < 55:
                    suffix[3] = ab[i3]
                    for i4 from 0 <= i4 < 55:
                        suffix[4] = ab[i4]
                        for i5 from 0 <= i5 < 55:
                            suffix[5] = ab[i5]
                            py_digest = hash(challenge+suffix).hexdigest()
                            digest = py_digest
                            for i from 0 <= i < hex_digits:
                                if digest[i] != c'0': break
                            else:
                                return suffix

虽然这个 Pyrex 函数看起来仍然比对应的 C 函数更加简单易读,但是它实际上最初的纯 Python 的版本更为复杂。通过这种方式,在纯 Python 中展开后缀生成与最初的版本相比会对总体速度有些负面的影响。在 Pyrex 中,正如您期望的一样,这些嵌套的循环都是很少花费时间的,因而我节省了转换和分时调度的代价:

清单 10. mint 函数 Pyrex 化优化后的速度结果
$ ./hashcash_test.py hashcash_pyx3 >/dev/null
13.2270 seconds (166125 hashes per second)

当然,这比我开始的时候好多了。但是速度提高也不过是两倍。大部分时间的问题是(此处也是)消耗了太多的时间在对 Python 库的调用上,而我并不能对这些调用编写代码来提高速度。

令人失望的比较

速度提高 50% 到 60% 似乎是值得的。达到这个目标我并没有编写 多少 代码。但是如果您认为是在原来的 Python 版本中添加 两条 语句 import psyco;psyco.bind(_mint),那么这种加速方法就不会给您多深的印象:

清单 11. mint 函数 Psyco 化的加速结果
$ ./hashcash_test.py hashcash_psyco >/dev/null
15.2300 seconds (157550 hashes per second)

换而言之,Psyco 之不过添加了两行通用的代码,就几乎能实现相同的目标。当然,Psyco 只能用于 x86 平台,而 Pyrex 可以在具有 C 编译器的所有环境上执行。但是对于这个特定的例子来说,os.popen('hashcash -m '+options) 的速度会比 Pyrex 和 Psyco 都快很多倍(当然,假设可以使用 C 工具 hashcash)。

何处是 Pyrex 的用武之地?

在最好的情况中,Pyrex 实际上可以产生非常快的代码。例如,Pyrex 主页上使用一个计算素数列表的数学函数来宣扬这个特性。所有涉及的操作都是对整型变量进行的,因此类型定义就可以极大地加速算法。这个 Pyrex 函数与纯 Python 的程序只有很少的不同:只是增加了几个声明:

清单 12. 查找素数的 Pyrex 函数
def primes(int kmax):
    # Calculate initial prime numbers
    cdef int n, k, i
    cdef int p[100000]
    result = []
    k = 0
    n = 2
    while k < kmax:
        i = 0
        while i < k and n % p[i] <> 0:
            i = i + 1
        if i == k:
            p[k] = n
            k = k + 1
            result.append(n)
        n = n + 1
    return result

我也编写了一个与实际的 Python 函数相同的函数,基本来说,只是去掉这些声明。运行这个函数的 Pyrex 和 Python 两个版本,以及 Psyco 化的 Python 版本,所需要的时间如下:

清单 13. Python、Psyco 和 Pyrex 版本的查找素数的函数的运行时间
$ ./prime_test.py
Pure Python version
First 10000 primes
60.30 seconds
Psyco-ized Python
First 10000 primes
7.62 seconds
Pyrex version
First 10000 primes
1.31 seconds

因此,在最佳情况中,Pyrex 比 Python 会好很多,加速情况也比 Psyco 要好。然而,我有一些程序可以通过修改一些算法的细节来提高 Psyco 的速度。即便如此,Pyrex 几乎肯定可以代表这种问题的最佳状况。所生成的 C 代码几乎与您使用 C 编写的代码完全相同。

结束语

Pyrex 有很多功能都实现得非常好。对于在循环中使用简单的数字或字符数据的代码来说,Pyrex 的加速效果非常明显,在最佳情况中,可能会是 50 倍。如果 Python 应用程序碰到数值函数方面的明显瓶颈,为这些函数创建一个 Pyrex 版本就非常有意义。但是在有些情况中,您会发现要想获得明显的提升是非常有限的。花费大部分时间在库函数调用上的代码不会像那些简单循环任务一样使用 Pyrex 可以获得明显的加速。而且,在很多情况中,增加两行代码启用 Psyco 就可以达到将 Python 代码中度修改为 Pyrex 所能达到的加速效果。虽然 Pyrex 代码很容易编写,但是您必须 编写 这些代码,这一点与 Psyco 不同。

我要说明本文中的 hashcash 可能不是您最想要的例子。我相信(经过更多工作之后)可以修改 Python sha 模块来启用直接调用 C 级接口的功能,这样就可以避免 Python 级的调用开销。也可能会找到更加优化的 SHA-1 的 C 实现。Pyrex 代码可以很完美地利用外部的 C 代码,调用使用 C 编写的 sha() 函数会比在 Python 对象和名称空间中装箱和拆箱该函数的速度更快。不过,如果有一个非常好的 hashcash 的现有 C 实现,就不知道这样做是否值得了。

然而,在使用 Pyrex 编写特殊的数值函数时,另外一个需要考虑的选项是是否可以使用 Numerical Python 作为工具。numeric 包非常通用,处理的速度也非常快。使用 numeric,终端用户并不需要涉及 任何 非 Python 代码,只需调用适当的库函数即可。尽管 numeric 的涵盖面当然与可以利用 Pyrex 的函数不同,但是肯定会有一些重叠。


相关主题


评论

添加或订阅评论,请先登录注册

static.content.url=http://www.ibm.com/developerworks/js/artrating/
SITE_ID=10
Zone=Linux
ArticleID=58229
ArticleTitle=可爱的 Python: Pyrex 扩展并加速 Python 应用程序
publish-date=02252005