Commit 3121b290 authored by Kirill Smelkov's avatar Kirill Smelkov

golang: Teach pychan to work with channels of C types, not only PyObjects

Introduce notion of data type (dtype similarly to NumPy) into pychan and
teach it to accept for send objects only matching that dtype. Likewise
teach pychan to decode raw bytes received from underlying channel into
Python object correspodningg to pychan dtype. For C dtypes, e.g.
'C.int', 'C.double' etc, contrary to chan of python objects, the
transfer can be done without depending on Python GIL. This way channels
of such C-level dtypes can be used to implement interaction in between
Python and nogil worlds.
parent 2c8063f4
......@@ -99,6 +99,14 @@ channels. For example::
# default case
...
By default `chan` creates new channel that can carry arbitrary Python objects.
However type of channel elements can be specified via `chan(dtype=X)` - for
example `chan(dtype='C.int')` creates new channel whose elements are C
integers. `chan.nil(X)` creates typed nil channel. `Cython/nogil API`_
explains how channels with non-Python dtypes, besides in-Python usage, can be
additionally used for interaction in between Python and nogil worlds.
Methods
-------
......@@ -238,6 +246,13 @@ can be used to multiplex on several channels. For example::
# default case
...
Channels created from Python are represented by `pychan` cdef class. Python
channels that carry non-Python elements (`pychan.dtype != DTYPE_PYOBJECT`) can
be converted to Cython/nogil `chan[T]` via `pychan.chan_*()`. For example
`pychan.chan_int()` converts Python channel created via `pychan(dtype='C.int')`
into `chan[int]`. This provides interaction mechanism in between *nogil* and
Python worlds.
`panic` stops normal execution of current goroutine by throwing a C-level
exception. On Python/C boundaries C-level exceptions have to be converted to
Python-level exceptions with `topyexc`. For example::
......
......@@ -110,6 +110,7 @@ cdef extern from "golang/libgolang.h" namespace "golang" nogil:
_chan *ch
_chanop op
unsigned flags
unsigned user
void *ptxrx
uint64_t itxrx
cbool *rxok
......@@ -127,9 +128,40 @@ cdef extern from "golang/libgolang.h" namespace "golang" nogil:
cdef void topyexc() except *
cpdef pypanic(arg)
# pychan is chan<object>
# pychan is python wrapper over chan<object> or chan<structZ|bool|int|double|...>
from cython cimport final
# DType describes type of channel elements.
# TODO consider supporting NumPy dtypes too.
cdef enum DType:
DTYPE_PYOBJECT = 0 # chan[object]
DTYPE_STRUCTZ = 1 # chan[structZ]
DTYPE_BOOL = 2 # chan[bool]
DTYPE_INT = 3 # chan[int]
DTYPE_DOUBLE = 4 # chan[double]
DTYPE_NTYPES = 5
# pychan wraps a channel into python object.
#
# Type of channel can be either channel of python objects, or channel of
# C-level objects. If channel elements are C-level objects, the channel - even
# via pychan wrapper - can be used to interact with nogil world.
#
# There can be multiple pychan(s) wrapping a particular raw channel.
@final
cdef class pychan:
cdef _chan *_ch
cdef DType dtype # type of channel elements
# pychan.nil(X) creates new nil pychan with element type X.
@staticmethod # XXX needs to be `cpdef nil()` but cython:
cdef pychan _nil(object dtype) # "static cpdef methods not yet supported"
# chan_X returns ._ch wrapped into typesafe pyx/nogil-level chan[X].
# chan_X panics if channel type != X.
# X can be any C-level type, but not PyObject.
cdef nogil:
chan[structZ] chan_structZ (pychan pych)
chan[cbool] chan_bool (pychan pych)
chan[int] chan_int (pychan pych)
chan[double] chan_double (pychan pych)
# -*- coding: utf-8 -*-
# cython: language_level=2
# cython: binding=False
# cython: c_string_type=str, c_string_encoding=utf8
# distutils: language = c++
# distutils: depends = libgolang.h
#
......@@ -142,25 +143,44 @@ cdef void __goviac(void *arg) nogil:
# ---- channels ----
# pychan is chan<object>.
@final
cdef class pychan:
def __cinit__(pychan pych, size=0):
pych._ch = _makechan_pyexc(sizeof(PyObject*), size)
def __cinit__(pychan pych, size=0, dtype=object):
pych.dtype = parse_dtype(dtype)
pych._ch = _makechan_pyexc(dtypeRegistry[<int>pych.dtype].size, size)
# pychan.nil(X) creates new nil pychan with specified dtype.
# TODO try to avoid exposing .nil on pychan instances, and expose only pychan.nil
# http://code.activestate.com/recipes/578486-class-only-methods/
@staticmethod
def nil(dtype):
return pychan._nil(dtype)
@staticmethod
cdef pychan _nil(object dtype):
return pynil(parse_dtype(dtype))
def __dealloc__(pychan pych):
# on del: drain buffered channel to decref sent objects.
# verify that the channel is not connected anywhere outside us.
# (if it was present also somewhere else - draining would be incorrect)
if pych._ch == NULL:
return
# pychan[X!=object]: just decref the raw chan and we are done.
if pych.dtype != DTYPE_PYOBJECT:
_chanxdecref(pych._ch)
pych._ch = NULL
return
# pychan[object], for now, owns the underlying channel.
# drain buffered channel to decref sent objects.
# verify that the channel is not connected anywhere outside us.
# (if it was present also somewhere else - draining would be incorrect)
#
# TODO: in the future there could be multiple pychan[object] wrapping
# the same underlying raw channel: e.g. ch=chan(); ch2=ch.txonly()
# -> drain underlying channel only when its last reference goes to 0.
cdef int refcnt = _chanrefcnt(pych._ch)
if refcnt != 1:
# cannot raise py-level exception in __dealloc__
Py_FatalError("pychan.__dealloc__: chan.refcnt=%d ; must be =1" % refcnt)
Py_FatalError("pychan[object].__dealloc__: chan.refcnt=%d ; must be =1" % refcnt)
cdef chan[pPyObject] ch = _wrapchan[pPyObject](pych._ch)
_chanxdecref(pych._ch)
......@@ -182,17 +202,23 @@ cdef class pychan:
# send sends object to a receiver.
def send(pychan pych, obj):
cdef PyObject *_tx = <PyObject*>obj
cdef chanElemBuf _tx = 0
# increment obj reference count - until received the channel is holding pointer to the object.
Py_INCREF(obj)
if pych.dtype == DTYPE_PYOBJECT:
# increment obj reference count - until received the channel is
# holding pointer to the object.
Py_INCREF(obj)
(<PyObject **>&_tx)[0] = <PyObject *>obj
else:
py_to_c(pych.dtype, obj, &_tx)
try:
with nogil:
_chansend_pyexc(pych._ch, &_tx)
except: # not only _PanicError as send can also throw e.g. bad_alloc
# the object was not sent - e.g. it was "send on a closed channel"
Py_DECREF(obj)
if pych.dtype == DTYPE_PYOBJECT:
Py_DECREF(obj)
raise
# recv_ is "comma-ok" version of recv.
......@@ -200,18 +226,23 @@ cdef class pychan:
# ok is true - if receive was delivered by a successful send.
# ok is false - if receive is due to channel being closed and empty.
def recv_(pychan pych): # -> (rx, ok)
cdef PyObject *_rx = NULL
cdef chanElemBuf _rx = 0
cdef bint ok
with nogil:
ok = _chanrecv__pyexc(pych._ch, &_rx)
if not ok:
return (None, ok)
cdef object rx = None
cdef PyObject *_rxpy
if pych.dtype == DTYPE_PYOBJECT:
_rxpy = (<PyObject **>&_rx)[0]
if _rxpy != NULL:
# we received the object and the channel dropped pointer to it.
rx = <object>_rxpy
Py_DECREF(rx)
else:
rx = c_to_py(pych.dtype, &_rx)
# we received the object and the channel dropped pointer to it.
rx = <object>_rx
Py_DECREF(rx)
return (rx, ok)
# recv receives from the channel.
......@@ -229,7 +260,10 @@ cdef class pychan:
def __repr__(pychan pych):
if pych._ch == NULL:
return "nilchan"
if pych.dtype == DTYPE_PYOBJECT:
return "nilchan"
else:
return "chan.nil(%r)" % dtypeinfo(pych.dtype).name
else:
return super(pychan, pych).__repr__()
......@@ -242,16 +276,41 @@ cdef class pychan:
cdef pychan b = rhs
if a._ch != b._ch:
return False
return True
# a and b point to the same underlying channel object.
# they compare as same if their types match, or, for nil, additionally,
# if one of the sides is nil[*] (untyped nil).
if a.dtype == b.dtype:
return True
if a._ch != NULL:
return False
if a.dtype == DTYPE_PYOBJECT or b.dtype == DTYPE_PYOBJECT:
return True
return False
# pynilchan is the nil py channel.
#
# On nil channel: send/recv block forever; close panics.
cdef pychan _pynilchan = pychan()
_chanxdecref(_pynilchan._ch)
_pynilchan._ch = NULL
pynilchan = _pynilchan
# pychan -> chan[X]
# ( should live in "runtime support for channel types" if we could define
# methods separate from class )
cdef nogil:
chan[structZ] chan_structZ (pychan pych):
pychan_asserttype(pych, DTYPE_STRUCTZ)
return _wrapchan[structZ](pych._ch)
chan[cbool] chan_bool (pychan pych):
pychan_asserttype(pych, DTYPE_BOOL)
return _wrapchan[cbool] (pych._ch)
chan[int] chan_int (pychan pych):
pychan_asserttype(pych, DTYPE_INT)
return _wrapchan[int] (pych._ch)
chan[double] chan_double (pychan pych):
pychan_asserttype(pych, DTYPE_DOUBLE)
return _wrapchan[double] (pych._ch)
cdef void pychan_asserttype(pychan pych, DType dtype) nogil:
if pych.dtype != dtype:
panic("pychan: channel type mismatch")
# pydefault represents default case for pyselect.
......@@ -288,7 +347,7 @@ def pyselect(*pycasev):
cdef int i, n = len(pycasev), selected
cdef vector[_selcase] casev = vector[_selcase](n, default)
cdef pychan pych
cdef PyObject *_rx = NULL # all select recvs are setup to receive into _rx
cdef chanElemBuf _rx = 0 # all select recvs are setup to receive into _rx
cdef cbool rxok = False # (its ok as only one receive will be actually executed)
selected = -1
......@@ -315,14 +374,20 @@ def pyselect(*pycasev):
pypanic("pyselect: send expected: %r" % (pysend,))
tx = <object>(_tcase.ob_item[1])
# incref tx as if corresponding channel is holding pointer to the object while it is being sent.
# we'll decref the object if it won't be sent.
# see pychan.send for details.
Py_INCREF(tx)
casev[i] = _selsend(pych._ch, NULL)
casev[i].flags = _INPLACE_DATA
(<PyObject **>&casev[i].itxrx)[0] = <PyObject *>tx
casev[i].user = pych.dtype
if pych.dtype == DTYPE_PYOBJECT:
# incref tx as if corresponding channel is holding pointer to the object while it is being sent.
# we'll decref the object if it won't be sent.
# see pychan.send for details.
Py_INCREF(tx)
(<PyObject **>&casev[i].itxrx)[0] = <PyObject *>tx
else:
# NOTE vvv assumes that size for all dtypes fit into 64 bits
py_to_c(pych.dtype, tx, &casev[i].itxrx) # NOTE can raise exception
# recv
else:
......@@ -338,13 +403,15 @@ def pyselect(*pycasev):
else:
pypanic("pyselect: recv expected: %r" % (pyrecv,))
casev[i].user = pych.dtype
with nogil:
selected = _chanselect_pyexc(&casev[0], casev.size())
finally:
# decref not sent tx (see ^^^ send prepare)
for i in range(n):
if casev[i].op == _CHANSEND and (i != selected):
if casev[i].op == _CHANSEND and casev[i].user == DTYPE_PYOBJECT and (i != selected):
_tx = (<PyObject **>casev[i].ptx())[0]
tx = <object>_tx
Py_DECREF(tx)
......@@ -358,12 +425,20 @@ def pyselect(*pycasev):
if op != _CHANRECV:
raise AssertionError("pyselect: chanselect returned with bad op")
# we received NULL or the object; if it is object, corresponding channel
# dropped pointer to it (see pychan.recv_ for details).
cdef object rx = None
if _rx != NULL:
rx = <object>_rx
Py_DECREF(rx)
cdef PyObject *_rxpy
cdef DType rxtype = <DType>casev[selected].user
if rxtype == DTYPE_PYOBJECT:
# we received NULL or the object; if it is object, corresponding channel
# dropped pointer to it (see pychan.recv_ for details).
_rxpy = (<PyObject **>&_rx)[0]
if _rxpy != NULL:
rx = <object>_rxpy
Py_DECREF(rx)
else:
rx = c_to_py(rxtype, &_rx)
if casev[selected].rxok != NULL:
return selected, (rx, rxok)
......@@ -444,3 +519,194 @@ cdef nogil:
void _taskgo_pyexc(void (*f)(void *) nogil, void *arg) except +topyexc:
_taskgo(f, arg)
# ---- runtime support for channel types ----
# chanElemBuf is large enough to keep any dtype.
# NOTE sizeof(chanElemBuf) = max(_.size) from dtypeRegistry (this is checked at
# runtime on module init).
ctypedef uint64_t chanElemBuf
# DTypeInfo provides runtime information for a DType:
# dtype name, element size, py <-> c element conversion routines and typed nil instance.
cdef struct DTypeInfo:
const char *name # name of the type, e.g. "C.int"
unsigned size
# py_to_c converts python object to C-level data of dtype.
# If conversion fails, corresponding exception is raised.
bint (*py_to_c)(object obj, chanElemBuf *cto) except False
# c_to_py converts C-level data into python object according to dtype.
# The conversion cannot fail, but this can raise exception e.g. due to
# error when allocating result object.
object (*c_to_py) (const chanElemBuf *cfrom)
# pynil points to pychan instance that represents nil[dtype].
# it holds one reference and is never freed.
PyObject *pynil
# py_to_c converts Python object to C-level data according to dtype.
cdef bint py_to_c(DType dtype, object obj, chanElemBuf *cto) except False:
dtypei = dtypeinfo(dtype)
return dtypei.py_to_c(obj, cto)
# c_to_py converts C-level data into Python object according to dtype.
cdef object c_to_py(DType dtype, const chanElemBuf *cfrom):
dtypei = dtypeinfo(dtype)
return dtypei.c_to_py(cfrom)
# mkpynil creates pychan instance that represents nil[dtype].
cdef PyObject *mkpynil(DType dtype):
cdef pychan pynil = pychan.__new__(pychan)
pynil.dtype = dtype
pynil._ch = NULL # should be already NULL
Py_INCREF(pynil)
return <PyObject *>pynil
# pynil returns pychan instance corresponding to nil[dtype].
cdef pychan pynil(DType dtype):
dtypei = dtypeinfo(dtype)
return <pychan>dtypei.pynil
# {} dtype -> DTypeInfo.
# XXX const
cdef DTypeInfo[<int>DTYPE_NTYPES] dtypeRegistry
# dtypeinfo returns DTypeInfo corresponding to dtype.
cdef DTypeInfo* dtypeinfo(DType dtype) nogil:
if not (0 <= dtype < DTYPE_NTYPES):
# no need to ->pyexc, as this bug means memory corruption and so is fatal
panic("BUG: pychan dtype invalid")
return &dtypeRegistry[<int>dtype]
# DTYPE_PYOBJECT
dtypeRegistry[<int>DTYPE_PYOBJECT] = DTypeInfo(
name = "object",
size = sizeof(PyObject*),
# py_to_c/c_to_py must not be called for pyobj - as pyobj is the common
# case, they are manually inlined for speed. The code is also more clear
# when Py_INCREF/Py_DECREF go in send/recv/select directly.
py_to_c = NULL, # must not be called for pyobj
c_to_py = NULL, # must not be called for pyobj
pynil = mkpynil(DTYPE_PYOBJECT),
)
# pynilchan is nil py channel.
#
# On nil channel: send/recv block forever; close panics.
# pynilchan is alias for pychan.nil(object).
pynilchan = pychan._nil(object)
# DTYPE_STRUCTZ
dtypeRegistry[<int>DTYPE_STRUCTZ] = DTypeInfo(
name = "C.structZ",
size = 0, # NOTE = _elemsize<structZ>, but _not_ sizeof(structZ) which = 1
py_to_c = structZ_py_to_c,
c_to_py = structZ_c_to_py,
pynil = mkpynil(DTYPE_STRUCTZ),
)
cdef bint structZ_py_to_c(object obj, chanElemBuf *cto) except False:
# for structZ the only accepted value from python is None
if obj is not None:
raise TypeError("type mismatch: expect structZ; got %r" % (obj,))
# nothing to do - size = 0
return True
cdef object structZ_c_to_py(const chanElemBuf *cfrom):
return None
# DTYPE_BOOL
dtypeRegistry[<int>DTYPE_BOOL] = DTypeInfo(
name = "C.bool",
size = sizeof(cbool),
py_to_c = bool_py_to_c,
c_to_py = bool_c_to_py,
pynil = mkpynil(DTYPE_BOOL),
)
cdef bint bool_py_to_c(object obj, chanElemBuf *cto) except False:
# don't accept int/double/str/whatever.
if type(obj) is not bool:
raise TypeError("type mismatch: expect bool; got %r" % (obj,))
(<cbool *>cto)[0] = obj # raises *Error if conversion fails
return True
cdef object bool_c_to_py(const chanElemBuf *cfrom):
return (<cbool *>cfrom)[0]
# DTYPE_INT
dtypeRegistry[<int>DTYPE_INT] = DTypeInfo(
name = "C.int",
size = sizeof(int),
py_to_c = int_py_to_c,
c_to_py = int_c_to_py,
pynil = mkpynil(DTYPE_INT),
)
cdef bint int_py_to_c(object obj, chanElemBuf *cto) except False:
# don't accept bool
if isinstance(obj, bool):
raise TypeError("type mismatch: expect int; got %r" % (obj,))
# don't allow e.g. 3.14 to be implicitly truncated to just 3
cdef double objf = obj
if (<int>objf) != objf:
raise TypeError("type mismatch: expect int; got %r" % (obj,))
(<int *>cto)[0] = obj # raises *Error if conversion fails
return True
cdef object int_c_to_py(const chanElemBuf *cfrom):
return (<int *>cfrom)[0]
# DTYPE_DOUBLE
dtypeRegistry[<int>DTYPE_DOUBLE] = DTypeInfo(
name = "C.double",
size = sizeof(double),
py_to_c = double_py_to_c,
c_to_py = double_c_to_py,
pynil = mkpynil(DTYPE_DOUBLE),
)
cdef bint double_py_to_c(object obj, chanElemBuf *cto) except False:
# don't accept bool
if isinstance(obj, bool):
raise TypeError("type mismatch: expect float; got %r" % (obj,))
(<double *>cto)[0] = obj # raises *Error if conversion fails
return True
cdef object double_c_to_py(const chanElemBuf *cfrom):
return (<double *>cfrom)[0]
# verify at init time that sizeof(chanElemBuf) = max(_.size)
cdef verify_chanElemBuf():
cdef int size_max = 0
for dtype in range(DTYPE_NTYPES):
size_max = max(size_max, dtypeRegistry[<int>dtype].size)
if size_max != sizeof(chanElemBuf):
raise AssertionError("golang: module is miscompiled: max(dtype.size) = %d ; compiled with = %d" % (size_max, sizeof(chanElemBuf)))
verify_chanElemBuf()
# {} dtype name (str) -> dtype
cdef dict name2dtype = {}
cdef init_name2dtype():
for dtype in range(DTYPE_NTYPES):
name2dtype[dtypeRegistry[<int>dtype].name] = dtype
init_name2dtype()
# parse_dtype converts object or string dtype, as e.g. passed to
# pychan(dtype=...) into DType.
cdef DType parse_dtype(dtype) except <DType>-1:
if dtype is object:
return DTYPE_PYOBJECT
_ = name2dtype.get(dtype)
if _ is None:
raise TypeError("pychan: invalid dtype: %r" % (dtype,))
return _
......@@ -210,3 +210,72 @@ def test_select_win_while_queue():
def test_select_inplace():
with nogil:
_test_select_inplace()
# helpers for pychan(dtype=X) py <-> c tests.
def pychan_structZ_recv(pychan pych):
with nogil: _pychan_structZ_recv(pych)
return None
def pychan_structZ_send(pychan pych, obj):
if obj is not None:
raise TypeError("cannot convert %r to structZ" % (obj,))
cdef structZ _
with nogil:
_pychan_structZ_send(pych, _)
def pychan_structZ_close(pychan pych):
with nogil: _pychan_structZ_close(pych)
def pychan_bool_recv(pychan pych):
with nogil: _ = _pychan_bool_recv(pych)
return _
def pychan_bool_send(pychan pych, cbool obj):
with nogil: _pychan_bool_send(pych, obj)
def pychan_bool_close(pychan pych):
with nogil: _pychan_bool_close(pych)
def pychan_int_recv(pychan pych):
with nogil: _ = _pychan_int_recv(pych)
return _
def pychan_int_send(pychan pych, int obj):
with nogil: _pychan_int_send(pych, obj)
def pychan_int_close(pychan pych):
with nogil: _pychan_int_close(pych)
def pychan_double_recv(pychan pych):
with nogil: _ = _pychan_double_recv(pych)
return _
def pychan_double_send(pychan pych, double obj):
with nogil: _pychan_double_send(pych, obj)
def pychan_double_close(pychan pych):
with nogil: _pychan_double_close(pych)
cdef nogil:
structZ _pychan_structZ_recv(pychan pych) except +topyexc:
return pych.chan_structZ().recv()
void _pychan_structZ_send(pychan pych, structZ obj) except +topyexc:
pych.chan_structZ().send(obj)
void _pychan_structZ_close(pychan pych) except +topyexc:
pych.chan_structZ().close()
cbool _pychan_bool_recv(pychan pych) except +topyexc:
return pych.chan_bool().recv()
void _pychan_bool_send(pychan pych, cbool obj) except +topyexc:
pych.chan_bool().send(obj)
void _pychan_bool_close(pychan pych) except +topyexc:
pych.chan_bool().close()
int _pychan_int_recv(pychan pych) except +topyexc:
return pych.chan_int().recv()
void _pychan_int_send(pychan pych, int obj) except +topyexc:
pych.chan_int().send(obj)
void _pychan_int_close(pychan pych) except +topyexc:
pych.chan_int().close()
double _pychan_double_recv(pychan pych) except +topyexc:
return pych.chan_double().recv()
void _pychan_double_send(pychan pych, double obj) except +topyexc:
pych.chan_double().send(obj)
void _pychan_double_close(pychan pych) except +topyexc:
pych.chan_double().close()
......@@ -29,6 +29,7 @@ from subprocess import Popen, PIPE
from six.moves import range as xrange
import gc, weakref
from golang import _golang_test
from golang._golang_test import pywaitBlocked as waitBlocked, pylen_recvq as len_recvq, \
pylen_sendq as len_sendq, pypanicWhenBlocked as panicWhenBlocked
......@@ -738,15 +739,160 @@ def _test_blockforever():
with panics("t: blocks forever"): select((z.send, 1), z.recv)
def test_chan_misc():
nilch = nilchan
# verify chan(dtype=X) functionality.
def test_chan_dtype_invalid():
with raises(TypeError) as exc:
chan(dtype="BadType")
assert exc.value.args == ("pychan: invalid dtype: 'BadType'",)
chantypev = [
# dtype obj zero-obj
('object', 'abc', None),
('C.structZ', None, None),
('C.bool', True, False),
('C.int', 4, 0),
('C.double', 3.14, 0.0),
]
@mark.parametrize('dtype,obj,zobj', chantypev)
def test_chan_dtype(dtype, obj, zobj):
# py -> py (pysend/pyrecv; buffered)
ch = chan(1, dtype=dtype)
ch.send(obj)
obj2, ok = ch.recv_()
assert ok == True
assert type(obj2) is type(obj)
assert obj2 == obj
# send with different type - rejected
for (dtype2, obj2, _) in chantypev:
if dtype2 == dtype or dtype == "object":
continue # X -> X; object accepts *,
if (dtype2, dtype) == ('C.int', 'C.double'): # int -> double ok
continue
with raises(TypeError) as exc:
ch.send(obj2)
# XXX we can implement vvv, but it will potentially hide cause error
# XXX (or use raise from?)
#assert exc.value.args == ("type mismatch: expect %s; got %r" % (dtype, obj2),)
with raises(TypeError) as exc:
select((ch.send, obj2))
# py -> py (pyclose/pyrecv)
ch.close()
obj2, ok = ch.recv_()
assert ok == False
assert type(obj2) is type(zobj)
assert obj2 == zobj
# below tests are for py <-> c interaction
if dtype == "object":
return
ctype = dtype[2:] # C.int -> int
ch = chan(dtype=dtype) # recreate after close; mode=synchronous
# recv/send/close via C
def crecv(ch):
return getattr(_golang_test, "pychan_%s_recv" % ctype)(ch)
def csend(ch, obj):
getattr(_golang_test, "pychan_%s_send" % ctype)(ch, obj)
def cclose(ch):
getattr(_golang_test, "pychan_%s_close" % ctype)(ch)
# py -> c (pysend/crecv)
rx = chan()
def _():
_ = crecv(ch)
rx.send(_)
go(_)
ch.send(obj)
obj2 = rx.recv()
assert type(obj2) is type(obj)
assert obj2 == obj
# py -> c (pyselect/crecv)
rx = chan()
def _():
_ = crecv(ch)
rx.send(_)
go(_)
_, _rx = select(
(ch.send, obj), # 0
)
assert (_, _rx) == (0, None)
obj2 = rx.recv()
assert type(obj2) is type(obj)
assert obj2 == obj
# py -> c (pyclose/crecv)
rx = chan()
def _():
_ = crecv(ch)
rx.send(_)
go(_)
ch.close()
obj2 = rx.recv()
assert type(obj2) is type(zobj)
assert obj2 == zobj
ch = chan(dtype=dtype) # recreate after close
# py <- c (pyrecv/csend)
def _():
csend(ch, obj)
go(_)
obj2 = ch.recv()
assert type(obj2) is type(obj)
assert obj2 == obj
# py <- c (pyselect/csend)
def _():
csend(ch, obj)
go(_)
_, _rx = select(
ch.recv, # 0
)
assert _ == 0
obj2 = _rx
assert type(obj2) is type(obj)
assert obj2 == obj
# py <- c (pyrecv/cclose)
def _():
cclose(ch)
go(_)
obj2 = ch.recv()
assert type(obj2) is type(zobj)
assert obj2 == zobj
@mark.parametrize('dtype', [_[0] for _ in chantypev])
def test_chan_dtype_misc(dtype):
nilch = chan.nil(dtype)
# nil repr
if dtype == "object":
assert repr(nilch) == "nilchan"
else:
assert repr(nilch) == ("chan.nil(%r)" % dtype)
assert nilch == nilch # nil == nil
# optimization: nil[X]() -> always same object
nilch_ = chan.nil(dtype)
assert nilch is nilch_
if dtype == "object":
assert nilch is nilchan
assert hash(nilch) == hash(nilchan)
assert nilch == nilch # nil[X] == nil[X]
assert nilch == nilchan # nil[X] == nil[*]
assert nilchan == nilch # nil[*] == nil[X]
# channels can be compared, different channels differ
assert nilch != None # just in case
ch1 = chan()
ch2 = chan()
ch1 = chan(dtype=dtype)
ch2 = chan(dtype=dtype)
ch3 = chan()
assert ch1 != ch2; assert ch1 == ch1
assert ch1 != ch3; assert ch2 == ch2
......@@ -758,6 +904,43 @@ def test_chan_misc():
assert nilch != ch2
assert nilch != ch3
# .nil on chan instance XXX doesn't work (yet ?)
"""
ch = chan() # non-nil chan object instance
with raises(AttributeError):
ch.nil
"""
# nil[X] vs nil[Y]
for (dtype2, _, _) in chantypev:
nilch2 = chan.nil(dtype2)
# nil[*] stands for untyped nil - it is equal to nil[X] for ∀ X
if dtype == "object" or dtype2 == "object":
if dtype != dtype2:
assert nilch is not nilch2
assert hash(nilch) == hash(nilch2)
assert (nilch == nilch2) == True
assert (nilch2 == nilch) == True
assert (nilch != nilch2) == False
assert (nilch2 != nilch) == False
continue
# nil[X] == nil[X]
if dtype == dtype2:
assert hash(nilch) == hash(nilch2)
assert (nilch == nilch2) == True
assert (nilch2 == nilch) == True
assert (nilch != nilch2) == False
assert (nilch2 != nilch) == False
continue
# nil[X] != nil[Y]
assert nilch is not nilch2
assert (nilch == nilch2) == False
assert (nilch2 == nilch) == False
assert (nilch != nilch2) == True
assert (nilch2 != nilch) == True
def test_func():
# test how @func(cls) works
......
......@@ -164,7 +164,9 @@ typedef struct _selcase {
_chan *ch; // channel
enum _chanop op : 8; // chansend/chanrecv/default
enum _selflags flags : 8; // e.g. _INPLACE_DATA
unsigned :16;
unsigned user : 8; // arbitrary value that can be set by user
// (e.g. pyselect stores channel type here)
unsigned : 8;
union {
void *ptxrx; // chansend: ptx; chanrecv: prx
uint64_t itxrx; // used instead of .ptxrx if .flags&_INPLACE_DATA != 0
......@@ -191,6 +193,7 @@ _selcase _selsend(_chan *ch, const void *ptx) {
.ch = ch,
.op = _CHANSEND,
.flags = (enum _selflags)0,
.user = 0xff,
.ptxrx = (void *)ptx,
.rxok = NULL,
};
......@@ -204,6 +207,7 @@ _selcase _selrecv(_chan *ch, void *prx) {
.ch = ch,
.op = _CHANRECV,
.flags = (enum _selflags)0,
.user = 0xff,
.ptxrx = prx,
.rxok = NULL,
};
......@@ -217,6 +221,7 @@ _selcase _selrecv_(_chan *ch, void *prx, bool *pok) {
.ch = ch,
.op = _CHANRECV,
.flags = (enum _selflags)0,
.user = 0xff,
.ptxrx = prx,
.rxok = pok,
};
......
......@@ -860,6 +860,7 @@ const _selcase _default = {
.ch = NULL,
.op = _DEFAULT,
.flags = (_selflags)0,
.user = 0xff,
.ptxrx = NULL,
.rxok = NULL,
};
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment