FrameworkBenchmarks 中的 web2py 基准测试:standard 与 optimized 双版本实现解析

原创2026-10-14 17:30:381,855 阅读
文章标签:性能测试测试质量保障后端示例工程Web框架

FrameworkBenchmarks 中的 web2py 基准测试:standard 与 optimized 双版本实现解析

导读

本文以 frameworks/Python/web2py/README.md 为核心,深度解析 web2py 在 TechEmpower FrameworkBenchmarks 基准测试套件中的完整实现方案。web2py 在此仓库中提供了 web2py-standard 与 web2py-optimized 两套测试:前者是常规 web2py 生产代码风格,后者则叠加了若干非常规但可移植的性能优化手段。读完本文,你将掌握 web2py 基准应用的应用结构、数据库访问层设计、路由与 WSGI 入口、Docker 构建流程、Meinheld + Gunicorn 的部署配置,以及从源码层面理解每项优化的实际作用。

一、测试方案总览:两套变体,一条基线

web2py 的基准测试同时维护了两套实现,均以 MySQL 为数据库、采用 "Realistic / Fullstack / Full ORM" 的测试定位,二者通过不同的 URL 前缀对外提供端点:

  • web2py-standard:/standard 前缀,实现方式为标准的 web2py 生产代码;
  • web2py-optimized:/optimized 前缀,包含若干"在性能敏感的极端场景下才值得采用"的优化手段,这些优化不会出现在典型的 web2py 应用中。

两套变体在 benchmark_config.json 中都有独立条目,测试类型元数据保持一致:

字段 web2py-standard web2py-optimized 含义
approach Realistic Realistic 真实场景测试
classification Fullstack Fullstack 全栈框架分类
database MySQL MySQL 被测数据库
orm Full Full 使用完整 ORM(同时存在原生 SQL 路径)
platform Meinheld Meinheld WSGI 服务器
webserver None None 无额外反向代理
flavor / notes Python2 / CPython 2.7 Python2 / CPython 2.7 基于 CPython 2.7
port 8080 8080 监听端口
tags ["broken"] ["broken"] 当前版本在配置中标记为 broken

需要如实指出:仓库当前的 config.toml 与 benchmark_config.json 均把两套测试标记为 tags: ["broken"],且运行环境为 CPython 2.7(两个 Dockerfile 均基于 python:2.7.15-stretch)。这意味着该实现是历史遗留的 Python 2 时代方案,读者应将其视为理解 web2py 基准测试架构与优化手法的参考案例,而非当前可立即投入生产运行的现代配置。

二、软件栈与依赖版本

README 文档明确了 web2py 基准测试使用的核心软件:

  • Meinheld 0.5.9 —— 高性能 WSGI 服务器;
  • Gunicorn 19.4.5 —— 提供 worker 进程管理;
  • greenlet 0.4.9 —— Meinheld 的协程基础;
  • MySQLdb 1.3.7 —— MySQL 驱动。

需要注意版本差异:README 记录的是文档撰写时点(较早轮次)的版本,而仓库当前生效的 requirements.txt 已升级为:

mysqlclient==1.3.12
gunicorn==19.7.1
meinheld==1.0.2
greenlet==0.4.14

以仓库实际文件为准,mysqlclient 取代了旧的 MySQLdb 包名(README 中仍写作 MySQLdb,对应 Python 2 时代 mysqlclient 的别名)。这一栈的组合逻辑在 frameworks/Python/README.md 中有明确解释:Gunicorn + Meinheld 组合用于在不带反向代理的情况下测量框架的裸性能(plaintext、json 测试),因为 Meinheld 对 slowloris 攻击安全且支持 Keep-Alive,可省去 nginx 之类的缓冲代理;而 Meinheld 自身不提供 worker 进程管理,因此由 Gunicorn 补足这一职责。

三、应用结构与共享控制器设计

web2py 基准应用位于仓库的 app/ 目录,包含两个可独立部署的 web2py application(web2py 框架的 application 与 Django app 概念不同,是一个包含 controllers/models/views 的完整目录树):

app/
├── standard/          # web2py-standard 应用
│   ├── controllers/default.py
│   ├── modules/controller.py     # 全部测试端点逻辑
│   ├── modules/database.py       # DAL / RawDal 数据访问层
│   └── views/fortune.html
├── optimized/         # web2py-optimized 应用
│   ├── models/app.py
│   └── views/fortune.html
├── routes.py          # 全局路由
└── wsgi.py            # WSGI 入口

3.1 控制器的复用:一个 module 两处挂载

最巧妙的设计在于,两套应用的业务逻辑完全共用同一个 controller 模块。standard 应用的 controllers/default.py 只做三件事:

import controller
from gluon import current

current.optimized = False  # 供 controller.py 判断是否启用 DAL 优化

session.forget(response)   # 不需要 session 时加速

def index():
    # URL 第一个参数指定要执行的 controller.py 中的函数
    return getattr(controller, request.args(0))()

由于 routes_in 把 /standard/$anything 映射到 /standard/default/index/$anything,index() 会取出路径第一段(如 json、db、queries),通过 getattr(controller, ...) 动态分发到 modules/controller.py 中对应的函数。这是典型的"薄控制器 + 模块复用"设计。

3.2 optimized 应用的差异化入口

optimized 应用的 models/app.py 则展示了两项关键优化:

from gluon import current
# 复用 standard 应用的 controller
from applications.standard.modules import controller

current.optimized = True   # 触发 controller.py 中的 DAL 优化分支

current.response._view_environment = current.globalenv
# 绕过控制器执行开销,直接在此返回响应
raise HTTP(200, getattr(controller, request.function)(), **current.response.headers)

这里通过 raise HTTP(200, ...) 在模型层直接返回响应,省去 web2py 正常控制器执行、视图渲染匹配等流水线开销;同时通过 routes.py 中针对 /optimized 前缀的路由配置进一步关停两项设施:

routes_in = [
    ('/standard/$anything', '/standard/default/index/$anything'),
    # 在 /optimized 路由上禁用 session 与垃圾回收以进一步提速
    ('/optimized/$anything', '/optimized/default/$anything',
     dict(web2py_disable_session=True, web2py_disable_garbage_collect=True))
]

也就是说,optimized 变体的优化共有四层:禁用 session、禁用请求级垃圾回收、模型层直接 raise HTTP 返回、复用 controller 中的 RawDal 原生 SQL 路径(见下文第四节)。

3.3 运行时分支开关:current.optimized

两套应用共享 controller,靠 current.optimized 标志在运行时切换行为。current 是 web2py 的线程局部存储对象,standard 在控制器中将其设为 False,optimized 在模型中将其设为 True。controller.py 中 queries()、updates()、fortune() 均据此选择 RawDal(原生 SQL)还是 Dal(ORM):

db = RawDal() if current.optimized else Dal('World')

这种"同一份逻辑、按部署环境切换实现"的方式,使得 standard 与 optimized 的差异点一目了然,便于对比分析优化效果。

四、数据库访问层:Dal 与 RawDal

数据库层集中在 app/standard/modules/database.py,这是 README 明确索引的第一份源码。其核心是 web2py 官方 DAL(Database Abstraction Layer)与手写原生 SQL 两套实现。

4.1 连接与表定义

DBHOST = 'tfb-database'
DATABASE_URI = 'mysql://benchmarkdbuser:benchmarkdbpass@%s:3306/hello_world' % DBHOST

class Dal(object):
    def __init__(self, table=None, pool_size=8):
        self.db = DAL(DATABASE_URI, migrate_enabled=False, pool_size=pool_size)
        if table == 'World':
            self.db.define_table('World', Field('randomNumber', 'integer'))
        elif table == 'Fortune':
            self.db.define_table('Fortune', Field('message'))

关键参数:

  • migrate_enabled=False:关闭表结构迁移检测,避免每个请求产生元数据查询开销;
  • pool_size=8:启用 DAL 自带的连接池;
  • 连接目标为 tfb-database:3306,即 FrameworkBenchmarks 测试网络中的 MySQL 容器主机名。

4.2 ORM 路径(standard)

Dal.get_world 使用 ORM 查询,并附带一条值得深入理解的注释:

def get_world(self, wid):
    # cacheable=True 通过省略创建某些非必要属性来提升性能;
    # 它并不真正缓存数据库结果,只是生成一个"可被缓存"的 Rows 对象。
    return self.db(self.db.World.id == wid).select(cacheable=True)[0].as_dict()

cacheable=True 是 web2py DAL 的性能开关,它跳过 Rows 对象中 response、db 等非必要属性的装配,从而降低单次查询的对象创建成本——注意它不缓存数据,只是让返回对象更轻量。get_fortunes 则在取出全部 Fortune 记录后,把新消息追加进 fortunes.records 再排序:

def get_fortunes(self, new_message):
    fortunes = self.db(self.db.Fortune).select(cacheable=True)
    fortunes.records.append(Row(new_message))
    return fortunes.sort(itemgetter('message'))

4.3 原生 SQL 路径(optimized)

RawDal 继承自 Dal,但把三个核心操作全部改写为 executesql 原生 SQL:

def get_world(self, wid):
    return self.db.executesql('SELECT * FROM World WHERE id = %s',
                              placeholders=[wid], as_dict=True)[0]

def update_world(self, wid, randomNumber):
    self.db.executesql('UPDATE World SET randomNumber=%s WHERE id=%s',
                       placeholders=[randomNumber, wid])

def get_fortunes(self, new_message):
    fortunes = self.db.executesql('SELECT * FROM Fortune', as_dict=True)
    fortunes.append(new_message)
    return sorted(fortunes, key=itemgetter('message'))

RawDal 的优化本质是绕过 DAL 的查询构建与对象映射,用占位符参数化 SQL 直连驱动层,同时保留 executesql 提供的注入防护。这是 README 中"包含若干特殊优化、性能关键场景下才会采用"的直接体现。

4.4 查询数量钳制

def num_queries(queries):
    try:
        num = int(queries)
        return 1 if num < 1 else 500 if num > 500 else num
    except ValueError:
        return 1

num_queries 把用户传入的 queries 参数钳制在 1 ~ 500 区间:小于 1 或非法输入一律按 1 处理,大于 500 按 500 处理。这符合 FrameworkBenchmarks 对"多查询"测试类型的参数边界要求,防止极端值拖垮被测框架。

五、测试端点与实现对照

README 给出的测试路径与 controller.py 中的函数一一对应。以下按 README 原列表整理,并补充仓库中的实际实现证据(路径前缀为 /standard,/optimized 同理):

测试类型 README 路径 controller 函数 返回内容
JSON 序列化 /standard/json json() {"message": "Hello, World!"}
单条数据库查询 /standard/db db() 单条 World 记录 JSON
多条数据库查询 /standard/dbs?queries=# queries() World 记录数组
Fortunes /standard/fortunes fortune() 渲染 fortune.html
数据库更新 /standard/update?queries=# updates() 更新后的 World 记录数组
Plaintext /standard/plaintext plaintext() Hello, World!

5.1 无数据库端点(plaintext / json)

def plaintext():
    current.response.headers['Content-Type'] = 'text/plain'
    return 'Hello, World!'

def json():
    current.response.headers['Content-Type'] = 'application/json'
    return jsonOut.dumps({'message': 'Hello, World!'})

plaintext 与 json 是"裸性能"测试,不触碰数据库,直接通过 current.response.headers 设置 Content-Type 后返回字符串,正是 frameworks/Python/README.md 所述"用 Meinheld 测量无反向代理、无 DB 访问的框架裸性能"的场景。

5.2 查询与更新端点(queries / updates)

def queries():
    current.response.headers['Content-Type']='application/json'
    db = RawDal() if current.optimized else Dal('World')
    get_world = db.get_world
    r10k = partial(randint, 1, 10000)
    worlds = [get_world(r10k()) for _ in
              xrange(num_queries(current.request.vars.queries))]
    return jsonOut.dumps(worlds)

queries() 使用 functools.partial 预绑定 randint(1, 10000) 与 get_world,在列表推导中依次随机取 10000 个 id 中的一条 World 记录;updates() 则对每条随机记录先 get_world 再 update_world 写入新随机数,按规范顺序完成读-改-写。

5.3 Fortunes 与模板渲染

def fortune():
    new_message = {'id': 0, 'message': 'Additional fortune added at request time.'}
    db = RawDal() if current.optimized else Dal('Fortune')
    fortunes = db.get_fortunes(new_message=new_message)
    return current.response.render('fortune.html', fortunes=fortunes)

Fortunes 测试要求:取出全部 Fortune 记录,追加一条固定的新消息(id 为 0,文案为 "Additional fortune added at request time."),按 message 排序后渲染 HTML 表格。视图模板 app/standard/views/fortune.html 使用 web2py 模板语法:

<table><tr><th>id</th><th>message</th></tr>
{{for fortune in fortunes:}}
  <tr><td>{{=fortune['id']}}</td><td>{{=fortune['message']}}</td></tr>
{{pass}}
</table>

optimized 应用的 fortune.html 与 standard 完全一致,保证两种变体渲染结果可被同一套测试校验逻辑比对。

5.4 关于路径命名的一点说明

细心的读者会发现:README 文档记录的路径是 /standard/dbs、/standard/update,而仓库当前的 benchmark_config.json 与 config.toml 中登记的却是 query_url = "/standard/queries?queries="、update_url = "/standard/updates?queries=";同时 controller.py 中定义的是 queries()、updates() 函数。由于 standard 应用通过 index() 的 getattr(controller, request.args(0))() 动态分发,实际可用的端点以 controller 函数名为准,即 /standard/queries 与 /standard/updates。README 中的 dbs / update 属于文档与配置不同步的历史笔误,测试框架实际按 benchmark_config.json 中的 URL 发起请求。

六、路由、WSGI 入口与 Docker 构建

6.1 WSGI 入口

app/wsgi.py 是部署的入口模块:

import sys
import os

path = os.path.dirname(os.path.abspath(__file__))
os.chdir(path)

if not os.path.isdir('applications'):
    raise RuntimeError('Running from the wrong folder')

sys.path = [path] + [p for p in sys.path if not p == path]
sys.stdout = sys.stderr

from gluon.main import wsgibase
application = wsgibase

它把工作目录切换到 web2py 框架根、确保 applications/ 目录存在,并导出 gluon.main.wsgibase 作为 WSGI 应用对象,供 Gunicorn 以 web2py.wsgi:application 形式加载。

6.2 Gunicorn 运行配置

gunicorn_conf.py 定义了完整的部署参数:

import multiprocessing
import os

_is_travis = os.environ.get('TRAVIS') == 'true'

workers = multiprocessing.cpu_count() * 3
if _is_travis:
    workers = 2

bind = "0.0.0.0:8080"
keepalive = 120
errorlog = '-'
pidfile = 'gunicorn.pid'
pythonpath = 'web2py'

worker_class = "meinheld.gmeinheld.MeinheldWorker"

def post_fork(server, worker):
    # 禁用访问日志
    import meinheld.server
    meinheld.server.set_access_logger(None)

要点包括:worker 数取 CPU 核数 ×3(CI 环境降为 2);绑定 0.0.0.0:8080;keepalive=120 秒支持长连接;通过 worker_class = "meinheld.gmeinheld.MeinheldWorker" 让 Gunicorn 托管 Meinheld worker;post_fork 钩子在每个 worker fork 后关闭访问日志,避免基准测试期间的日志 I/O 干扰。

6.3 Docker 构建流程

两个 Dockerfile(web2py.dockerfile 与 web2py-optimized.dockerfile)构建步骤几乎一致,仅 web2py 源码检出点不同。以标准版为例:

FROM python:2.7.15-stretch
ADD ./ /web2py
WORKDIR /web2py
RUN pip install -r /web2py/requirements.txt
RUN git clone --recursive --branch master https://github.com/web2py/web2py.git
WORKDIR /web2py/web2py
# 版本 R-2.17.2
RUN git checkout 95709e582d586bd1871ab0fe9f6f265c1884bbe3
WORKDIR /web2py
RUN cp -r app/standard/ web2py/applications/
RUN cp -r app/optimized/ web2py/applications/
RUN cp app/wsgi.py web2py/
RUN cp app/routes.py web2py/
RUN touch web2py/__init__.py
RUN python compile_apps.py
WORKDIR /web2py
EXPOSE 8080
CMD gunicorn web2py.wsgi:application -c gunicorn_conf.py

值得注意的差异点:optimized 变体检出的 web2py 提交不同。Dockerfile 注释说明,optimized 检出的是最新稳定版之后的提交 623f3b99477eb97ffadb20d6f7cb3da398253c9c,目的是"利用最新稳定版发布后修复的若干 bug",后续轮次新稳定版发布后可以再调整。这意味着 standard 与 optimized 之间的性能差异除应用层优化外,还叠加了 web2py 框架本身的版本差异。

构建期间还会执行 compile_apps.py,调用 gluon.compileapp.compile_application 对 standard 与 optimized 两个 application 做字节码预编译:

compile_application(os.path.join(path, 'applications', 'standard'))
compile_application(os.path.join(path, 'applications', 'optimized'))

预编译把 web2py 的模板与 Python 源码提前编译,避免运行时首次请求的编译开销,是构建期的又一项性能措施。

6.4 运行方式

镜像构建完成后,容器启动命令为:

gunicorn web2py.wsgi:application -c gunicorn_conf.py

即由 Gunicorn 依据 gunicorn_conf.py 启动 web2py.wsgi 模块中的 application,在 8080 端口对外提供 /standard/* 与 /optimized/* 两套测试端点。测试框架将按 benchmark_config.json 登记的 URL 依次请求,并对照 toolset/test_types/ 中各测试类型的验证逻辑检查响应。

七、优化手法总结:standard → optimized 的增量

对照两套实现,可以把 README 所述的"若干特殊优化"归纳为可直接迁移的性能实践:

  1. 关闭 session:standard 在控制器调用 session.forget(response);optimized 更进一步,由路由级 web2py_disable_session=True 在请求进入应用前即禁用。
  2. 禁用垃圾回收:路由级 web2py_disable_garbage_collect=True 避免每请求触发 GC。
  3. 模型层直接返回:optimized 在 models/app.py 中 raise HTTP(200, ...) 绕过控制器执行流水线。
  4. 原生 SQL 数据层:RawDal 用 executesql 替代 DAL ORM,用于 queries / updates / fortunes 三个数据库测试。
  5. DAL 细粒度调优:即便 ORM 路径,也使用 cacheable=True(省去非必要属性装配)与 pool_size=8 连接池、migrate_enabled=False 关闭迁移检测。
  6. 构建期预编译:compile_apps.py 提前编译 application,消除首请求编译成本。
  7. 部署层调优:Meinheld worker + keepalive=120 + 禁用访问日志,最大化 WSGI 层吞吐。

其中前四点正是 standard 与 optimized 的核心差异所在,也是 README"后者包含若干不典型的 web2py 优化、但在性能关键场景可实施"这句描述的源码级注脚。

八、延伸阅读

登录后查看全文
FrameworkBenchmarks