Chinaunix首页 | 论坛 | 博客

timespace的CU博客

首页　| 　博文目录　| 　关于我

timespace

  • 博客访问： 179260
  • 博文数量： 13
  • 博客积分： 10
  • 博客等级： 民兵
  • 技术积分： 832
  • 用 户 组： 普通用户
  • 注册时间： 2010-12-16 22:43
个人简介

最近关注Python，Linux，LLVM

文章分类

全部博文（13）

文章存档

2014年（13）

我的朋友
最近访客
推荐博文
相关博文
浅析Python调用外部代码的三种方式（中篇）

分类： Python/Ruby

2014-03-03 10:17:32

(承接上篇)

六. C/C++ Extending标准库

场景。无可用Python模块，将C API整合到Python类型系统中，造福众人。

实现。

1. 假设已经写好C扩展（后面介绍实现），Python调用C扩展再次实现一遍同样的需求。

点击(此处)折叠或打开(notify3.py)

  1. import datetime
  2. import inotify
  3. import sys

  5. MASK_EVENTS = [(k,v) for k,v in sorted(list(inotify.__dict__.items()))
  6.          if k.startswith('IN_') and \
  7.                  k not in ('IN_CLOEXEC', 'IN_NONBLOCK') and \
  8.                  v == (v & ~(v-1))]

  10. def print_event(filename, mask):
  11.     now = datetime.datetime.now()
  12.     print('{:02}:{:02}:{:02},{:03} file({file}) {mask}'.format(
  13.         now.hour, now.minute, now.second, now.microsecond//1000,
  14.         file=filename,
  15.         mask=' '.join(k for k,v in MASK_EVENTS if mask & v)))

  17. def main():
  18.     if len(sys.argv) != 2:
  19.         sys.exit('usage: {} path'.format(sys.argv[0]))
  20.     pathname = sys.argv[1]

  22.     notify = inotify.inotify()
  23.     wd = notify.add_watch(pathname, inotify.IN_ALL_EVENTS)
  24.     while True:
  25.         evs = notify.read_events(1024)
  26.         for wd,mask,cookie,name in evs:
  27.             print_event(pathname if name is None else name, mask)
  28.     notify.rm_watch(wd)
  29.     notify.close()

  31. if __name__ == '__main__':
  32.     main()
从编码风格来看，很难看出C style了，尤其是和C密切相关的结构体对齐和宏定义。
行2：inotify就是用C扩展的Python Module，所有C和OS的细节全部封装在内。
行5～8：此处仅为说明C扩展后的Module就像一个真正纯Python定义的Module，这个风格与Python的可读性原则不符，请勿模仿。if语句目的是提取模块中的mask常量定义，其一名称以“IN_”开头（如IN_OPEN等），其二名称不是IN_CLOEXEC和IN_NONBLOCK，它们是inotify_init的flags，不同于inotify_add_watch的flags，必须排除，其三为了打印输出简洁，必须是原子flag（如IN_MOVE_TO）而非复合flag(IN_MOVE == IN_MOVE_FROM | IN_MOVE_TO)，，inotify定义的原子flag的数值均等于2 ** n（n 为非负整数），其数值满足位运算v == (v & ~(v-1))。
行25～26：经过封装返回的事件是Python的内置类型，此处是[(wd, mask, cookie, name), (...)]，一个由tuple构成的list，文件名name是str。

2. C扩展分析。通过Python C API将inotify C API集成到Python类型系统中，参考了CPython源码树中的Modules/selectmodule.c，乍看比较复杂，其实多数是程式化步骤。如果没有接触过C/C++ Extending，建议先读下官方文档的扩展入门部分，然后结合下文分析会更容易理解。

写C扩展时，第一个要弄清楚的就是引用计数（reference count），下面列出有关tips：
  • reference count源于Python对象（对应C API的PyObject *）的内存管理，表示有多少个用户引用了该对象，当该值为0时，对象内存即被回收。
  • Python对象的内存由Python堆内存管理器（Python heap manager）统一协调，意味着为Python对象分配内存，不能用C的malloc/free系列函数，因为他们是C heap，不同于Python heap，即使为非Python对象提供内存也应该用Python heap提供的PyMem_Malloc/PyMem_Free系列函数，便于Python heap做全局内存诊断和优化。
  • reference count的增大和减少，必须由用户显式控制，Py_INCREF(x)和Py_DECREF(x)分别是增加和减少x的引用计数，Py_INCREF(x)意味着用户对该对象的所有权，在显式Py_DECREF(x)之前，用户必定可以访问x而保证其不被回收。
  • reference count的变化意味着用户对该对象所有权（Ownership）的变化。作为函数入参的对象，Ownership通常不会变化，但有两个例外，其一是需要将该对象保存时，会调Py_INCREF，比如PyList_Append()，其二是遇到特例函数PyTuple_SetItem()/PyList_SetItem()，它们会接管所有权，而不调用Py_INCREF。作为函数返回值的对象，Ownership通常会改变，但有例外，这四个函数PyTuple_GetItem()/PyList_GetItem()/PyDict_GetItem()/PyDict_GetItemString()就是特例，它们返回的对象Ownership无变化，调用方只有使用权，如果想声明所有权必须显式调用Py_INCREF。

C扩展的前半部分，包括inotify的成员函数，也是模块使用者最应该关心的部分。

点击(此处)折叠或打开(inotifymodule.c)

  1. #include <Python.h>
  2. #include <sys/inotify.h>

  4. #define EVENT_SIZE_MAX (sizeof(struct inotify_event) + NAME_MAX + 1)
  5. #define EVENT_SIZE_MIN (sizeof(struct inotify_event))

  7. typedef struct {
  8.     PyObject_HEAD
  9.     int fd;
  10. } pyinotify;

  12. static PyObject *
  13. pyinotify_err_closed(void)
  14. {
  15.     PyErr_SetString(PyExc_ValueError,
  16.              "I/O operation on closed inotify object");
  17.     return NULL;
  18. }
  19. static int
  20. pyinotify_internal_close(pyinotify *self)
  21. {
  22.     int save_errno = 0;
  23.     if (self->fd >= 0) {
  24.         int fd = self->fd;
  25.         self->fd = -1;
  26.         Py_BEGIN_ALLOW_THREADS
  27.         if (close(fd) < 0)
  28.             save_errno = errno;
  29.         Py_END_ALLOW_THREADS
  30.     }
  31.     return save_errno;
  32. }

  34. static PyObject*
  35. pyinotify_get_closed(pyinotify *self)
  36. {
  37.     if (self->fd < 0)
  38.         Py_RETURN_TRUE;
  39.     else
  40.         Py_RETURN_FALSE;
  41. }

  43. PyDoc_STRVAR(pyinotify_add_watch_doc,
  44. "add_watch(pathname, mask) -> wd.\n\
  45. \n\
  46. Add a watch to the inotify instance, and watch descriptor returned.");

  48. static PyObject *
  49. pyinotify_add_watch(pyinotify *self, PyObject *args)
  50. {
  51.     PyObject *pathname;    
  52.     uint32_t mask;
  53.     int wd;

  55.     if (!PyArg_ParseTuple(args, "O&I:add_watch",
  56.                 PyUnicode_FSConverter, &pathname, &mask))
  57.         return NULL;

  59.     if (self->fd < 0)
  60.         return pyinotify_err_closed();

  62.     Py_BEGIN_ALLOW_THREADS
  63.     wd = inotify_add_watch(self->fd, PyBytes_AsString(pathname), mask);
  64.     Py_END_ALLOW_THREADS
  65.     Py_DECREF(pathname);    
  66.     if (wd == -1) {
  67.         PyErr_SetFromErrno(PyExc_OSError);
  68.         return NULL;
  69.     }

  71.     return PyLong_FromLong(wd);
  72. }

  74. PyDoc_STRVAR(pyinotify_rm_watch_doc,
  75. "rm_watch(wd) -> None.\n\
  76. \n\
  77. remove an existing watch descriptor from the inotify instance");

  79. static PyObject *
  80. pyinotify_rm_watch(pyinotify *self, PyObject *args)
  81. {
  82.     int wd;
  83.     int result;

  85.     if (!PyArg_ParseTuple(args, "i:rm_watch", &wd))
  86.         return NULL;

  88.     if (self->fd < 0)
  89.         return pyinotify_err_closed();

  91.     Py_BEGIN_ALLOW_THREADS
  92.     result = inotify_rm_watch(self->fd, wd);
  93.     Py_END_ALLOW_THREADS
  94.     if (result == -1) {
  95.         PyErr_SetFromErrno(PyExc_OSError);
  96.         return NULL;
  97.     }

  99.     Py_RETURN_NONE;
  100. }

  102. PyDoc_STRVAR(pyinotify_read_doc,
  103. "read(n) -> bytes\n\
  104. \n\
  105. Read events from the inotify instance.\n\
  106. at most n bytes will be returned.");

  108. static PyObject *
  109. pyinotify_read(pyinotify *self, PyObject *args)
  110. {
  111.     PyObject *evs;
  112.     Py_ssize_t result;
  113.     size_t nbyte;
  114.     char *buf;

  116.     if (!PyArg_ParseTuple(args, "I:read", &nbyte))
  117.         return NULL;
  118.     if (nbyte < EVENT_SIZE_MAX)
  119.         nbyte = EVENT_SIZE_MAX;

  121.     if (self->fd < 0)
  122.         return pyinotify_err_closed();

  124.     buf = (char *)PyMem_Malloc(nbyte);
  125.     if (buf == NULL) {
  126.         PyErr_NoMemory();
  127.         return NULL;
  128.     }
  129.     Py_BEGIN_ALLOW_THREADS
  130.     result = read(self->fd, buf, nbyte);
  131.     Py_END_ALLOW_THREADS
  132.     if (result < (Py_ssize_t)EVENT_SIZE_MIN) {
  133.         PyMem_Free(buf);
  134.         PyErr_SetFromErrno(PyExc_OSError);
  135.         return NULL;
  136.     }
  137.     evs = PyBytes_FromStringAndSize(buf, result);
  138.     PyMem_Free(buf);

  140.     return evs;
  141. }

  143. PyDoc_STRVAR(pyinotify_read_events_doc,
  144. "read_events(n) -> [(wd, mask, cookie, name), (...)].\n\
  145. \n\
  146. Read events from the inotify instance.\n\
  147. at most n bytes will be read, and then unpacked.");

  149. static PyObject *
  150. pyinotify_read_events(pyinotify *self, PyObject *args)
  151. {
  152.     PyObject *elist = NULL;
  153.     PyObject *etuple = NULL;
  154.     struct inotify_event *eptr = NULL;
  155.     size_t nbyte = 0;
  156.     char *buf = NULL;
  157.     Py_ssize_t result = -1; /* bytes in #buf. */
  158.     Py_ssize_t cnt = 0; /* count the events in #buf. */
  159.     Py_ssize_t offset = 0; /* offset in #buf or #elist. */

  161.     if (!PyArg_ParseTuple(args, "I:read", &nbyte))
  162.         return NULL;
  163.     if (nbyte < EVENT_SIZE_MAX)
  164.         nbyte = EVENT_SIZE_MAX;

  166.     if (self->fd < 0)
  167.         return pyinotify_err_closed();

  169.     buf = (char *)PyMem_Malloc(nbyte);
  170.     if (buf == NULL) {
  171.         PyErr_NoMemory();
  172.         return NULL;
  173.     }
  174.     Py_BEGIN_ALLOW_THREADS
  175.     result = read(self->fd, buf, nbyte);
  176.     Py_END_ALLOW_THREADS
  177.     if (result < (Py_ssize_t)EVENT_SIZE_MIN) {
  178.         PyErr_SetFromErrno(PyExc_OSError);
  179.         goto error;
  180.     }

  182.     for (cnt = 0, offset = 0; offset < result; ++cnt) {
  183.         eptr = (struct inotify_event *)(buf + offset);
  184.         offset += sizeof(*eptr) + eptr->len;
  185.     }
  186.     elist = PyList_New(cnt);
  187.     if (elist == NULL) {
  188.         PyErr_NoMemory();
  189.         goto error;
  190.     }

  192.     eptr = (struct inotify_event *)buf;
  193.     for (offset = 0; offset < cnt; ++offset) {
  194.         if (eptr->len > 1) {
  195.             etuple = Py_BuildValue("iIIO&",
  196.                      eptr->wd, eptr->mask, eptr->cookie,
  197.                          PyUnicode_DecodeFSDefault, eptr->name);
  198.         } else {
  199.             etuple = Py_BuildValue("iIIy",
  200.                      eptr->wd, eptr->mask, eptr->cookie, NULL);
  201.         }
  202.         if (etuple == NULL) {
  203.             Py_CLEAR(elist);
  204.             goto error;
  205.         }
  206.         if (PyList_SetItem(elist, offset, etuple) == -1) {
  207.             Py_CLEAR(etuple);
  208.             Py_CLEAR(elist);
  209.             goto error;
  210.         }
  211.         eptr = (struct inotify_event *)((char *)eptr + sizeof(*eptr) + eptr->len);
  212.     }

  214. error:
  215.     PyMem_Free(buf);
  216.     return elist;
  217. }

  219. PyDoc_STRVAR(pyinotify_close_doc,
  220. "close() -> None.\n\
  221. \n\
  222. close the inotify instance");

  224. static PyObject *
  225. pyinotify_close(pyinotify *self, PyObject *args)
  226. {
  227.     errno = pyinotify_internal_close(self);
  228.     if (errno < 0) {
  229.         PyErr_SetFromErrno(PyExc_OSError);
  230.         return NULL;
  231.     }
  232.     Py_RETURN_NONE;
  233. }
仔细浏览会发现各函数实现大同小异，这里只分析一个典型的函数pyinotify_read_events
行7～10：inotify对象的实际定义，唯一可见的成员就是inotify_init1返回的fd。
行143～147：pyinotify_read_events的文档，是函数实现的一部分，按照标准库的风格，硬编了几句英文。
行149～150：pyinotify_read_events的接口声明，该函数与Python代码直接交互，返回值必须是PyObject *，作为inotify对象的成员函数，第一个参数是对象本身PyObject *self，第二个参数是函数需要的所有参数PyObject *args
行161～162：解析pyinotify_read_events被调用时的入参，这是一个标准步骤，其他函数也是类似的。如果解析失败，PyArg_ParseTuple内部会设置异常类型，“return NULL”将告诉解释器终止当前代码运行，抛出异常。
行169～173：分配内存以存储内核将来返回的事件，最好利用Python heap提供的函数PyErr_NoMemory，当分配失败后，用户负责设置异常类型PyErr_NoMemory。
行174～176：读取内核事件，进行IO操作的前后，必须分别释放Py_BEGIN_ALLOW_THREADS和获取Py_END_ALLOW_THREADS全局解释锁（GIL，global interpreter lock），该原则适用所有C扩展。
行182～185：获取buf中事件的总数，struct inotify_event的真实内容是变长的，这里只能遍历一次buf才能获取事件总数。
行195～197：每个struct inotfiy_event构造一个tuple，read返回文件名是一个C字符串，要用PyUnicode_DecodeFSDefault解码为Python的str。
行206～209：每个struct inotfiy_event产生的etuple（对应Python tuple）都会保存到elist（对应Python list），注意此处PyList_SetItem会直接接管etuple对象，而不进行Py_INCREF(etuple)，这是Python C API中为数不多的特例。如果执行失败，保证etuple, elist, buf的内存都要释放。

（更多内容参见下篇）
阅读(3012) | 评论(0) | 转发(1) |
0

上一篇：浅析Python调用外部代码的三种方式（上篇）

下一篇：浅析Python调用外部代码的三种方式（下篇）

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6