Mirror
/
cpython
mirror of https://github.com/python/cpython
4
1
Fork 0
Code Issues Releases Wiki Activity

Update to use the new \csimplemacro macro

This commit is contained in:
Fred Drake 2002-04-09 21:09:42 +00:00
parent 79bf99c505
commit 375e30225e
2 changed files with 24 additions and 22 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

36
Doc/api/init.tex
View File

@ -391,12 +391,13 @@ Py_BEGIN_ALLOW_THREADS
Py_END_ALLOW_THREADS
\end{verbatim}
The \code{Py_BEGIN_ALLOW_THREADS}\ttindex{Py_BEGIN_ALLOW_THREADS} macro
opens a new block and declares a hidden local variable; the
\code{Py_END_ALLOW_THREADS}\ttindex{Py_END_ALLOW_THREADS} macro closes
the block. Another advantage of using these two macros is that when
Python is compiled without thread support, they are defined empty,
thus saving the thread state and lock manipulations.
The
\csimplemacro{Py_BEGIN_ALLOW_THREADS}\ttindex{Py_BEGIN_ALLOW_THREADS}
macro opens a new block and declares a hidden local variable; the
\csimplemacro{Py_END_ALLOW_THREADS}\ttindex{Py_END_ALLOW_THREADS}
macro closes the block. Another advantage of using these two macros
is that when Python is compiled without thread support, they are
defined empty, thus saving the thread state and lock manipulations.
When thread support is enabled, the block above expands to the
following code:
@ -574,30 +575,31 @@ look for example usage in the Python source distribution.
This macro expands to
\samp{\{ PyThreadState *_save; _save = PyEval_SaveThread();}.
Note that it contains an opening brace; it must be matched with a
following \code{Py_END_ALLOW_THREADS} macro. See above for further
discussion of this macro. It is a no-op when thread support is
disabled at compile time.
following \csimplemacro{Py_END_ALLOW_THREADS} macro. See above for
further discussion of this macro. It is a no-op when thread support
is disabled at compile time.
\end{csimplemacrodesc}
\begin{csimplemacrodesc}{Py_END_ALLOW_THREADS}
This macro expands to \samp{PyEval_RestoreThread(_save); \}}.
Note that it contains a closing brace; it must be matched with an
earlier \code{Py_BEGIN_ALLOW_THREADS} macro. See above for further
discussion of this macro. It is a no-op when thread support is
disabled at compile time.
earlier \csimplemacro{Py_BEGIN_ALLOW_THREADS} macro. See above for
further discussion of this macro. It is a no-op when thread support
is disabled at compile time.
\end{csimplemacrodesc}
\begin{csimplemacrodesc}{Py_BLOCK_THREADS}
This macro expands to \samp{PyEval_RestoreThread(_save);}: it is
equivalent to \code{Py_END_ALLOW_THREADS} without the closing brace.
It is a no-op when thread support is disabled at compile time.
equivalent to \csimplemacro{Py_END_ALLOW_THREADS} without the
closing brace. It is a no-op when thread support is disabled at
compile time.
\end{csimplemacrodesc}
\begin{csimplemacrodesc}{Py_UNBLOCK_THREADS}
This macro expands to \samp{_save = PyEval_SaveThread();}: it is
equivalent to \code{Py_BEGIN_ALLOW_THREADS} without the opening
brace and variable declaration. It is a no-op when thread support
is disabled at compile time.
equivalent to \csimplemacro{Py_BEGIN_ALLOW_THREADS} without the
opening brace and variable declaration. It is a no-op when thread
support is disabled at compile time.
\end{csimplemacrodesc}
All of the following functions are only available when thread support

10
Doc/ext/extending.tex
View File

@ -1068,11 +1068,11 @@ involving threads. Normally, multiple threads in the Python
interpreter can't get in each other's way, because there is a global
lock protecting Python's entire object space. However, it is possible
to temporarily release this lock using the macro
\code{Py_BEGIN_ALLOW_THREADS}, and to re-acquire it using
\code{Py_END_ALLOW_THREADS}. This is common around blocking I/O
calls, to let other threads use the processor while waiting for the I/O to
complete. Obviously, the following function has the same problem as
the previous one:
\csimplemacro{Py_BEGIN_ALLOW_THREADS}, and to re-acquire it using
\csimplemacro{Py_END_ALLOW_THREADS}. This is common around blocking
I/O calls, to let other threads use the processor while waiting for
the I/O to complete. Obviously, the following function has the same
problem as the previous one:
\begin{verbatim}
bug(PyObject *list) {