next_id; (int64_t)
mutex (PyThread_type_lock)
head (linked list of struct _channelref *):
- id (int64_t)
+ cid (int64_t)
objcount (Py_ssize_t)
next (struct _channelref *):
...
numsendopen (int64_t)
numrecvopen (int64_t)
send (struct _channelend *):
- interp (int64_t)
+ interpid (int64_t)
open (int)
next (struct _channelend *)
recv (struct _channelend *):
data (_PyCrossInterpreterData *):
data (void *)
obj (PyObject *)
- interp (int64_t)
+ interpid (int64_t)
new_object (xid_newobjectfunc)
free (xid_freefunc)
last (struct _channelitem *):
typedef struct {
PyObject_HEAD
Py_buffer *view;
- int64_t interp;
+ int64_t interpid;
} XIBufferViewObject;
static PyObject *
{
assert(data->data != NULL);
assert(data->obj == NULL);
- assert(data->interp >= 0);
+ assert(data->interpid >= 0);
XIBufferViewObject *self = PyObject_Malloc(sizeof(XIBufferViewObject));
if (self == NULL) {
return NULL;
}
PyObject_Init((PyObject *)self, cls);
self->view = (Py_buffer *)data->data;
- self->interp = data->interp;
+ self->interpid = data->interpid;
return (PyObject *)self;
}
static void
xibufferview_dealloc(XIBufferViewObject *self)
{
- PyInterpreterState *interp = _PyInterpreterState_LookUpID(self->interp);
+ PyInterpreterState *interp = _PyInterpreterState_LookUpID(self->interpid);
/* If the interpreter is no longer alive then we have problems,
since other objects may be using the buffer still. */
assert(interp != NULL);
#define CHANNEL_BOTH 0
#define CHANNEL_RECV -1
+
/* channel errors */
#define ERR_CHANNEL_NOT_FOUND -2
return 1;
}
+
/* the channel queue */
typedef uintptr_t _channelitem_id_t;
item->next = NULL;
if (item->data != NULL) {
- // It was allocated in _channel_send().
+ // It was allocated in channel_send().
(void)_release_xid_data(item->data, XID_IGNORE_EXC & XID_FREE);
item->data = NULL;
}
}
static void
-_channelqueue_drop_interpreter(_channelqueue *queue, int64_t interp)
+_channelqueue_clear_interpreter(_channelqueue *queue, int64_t interpid)
{
_channelitem *prev = NULL;
_channelitem *next = queue->first;
while (next != NULL) {
_channelitem *item = next;
next = item->next;
- if (item->data->interp == interp) {
+ if (item->data->interpid == interpid) {
if (prev == NULL) {
queue->first = item->next;
}
}
}
+
/* channel-interpreter associations */
struct _channelend;
typedef struct _channelend {
struct _channelend *next;
- int64_t interp;
+ int64_t interpid;
int open;
} _channelend;
static _channelend *
-_channelend_new(int64_t interp)
+_channelend_new(int64_t interpid)
{
_channelend *end = GLOBAL_MALLOC(_channelend);
if (end == NULL) {
return NULL;
}
end->next = NULL;
- end->interp = interp;
+ end->interpid = interpid;
end->open = 1;
return end;
}
}
static _channelend *
-_channelend_find(_channelend *first, int64_t interp, _channelend **pprev)
+_channelend_find(_channelend *first, int64_t interpid, _channelend **pprev)
{
_channelend *prev = NULL;
_channelend *end = first;
while (end != NULL) {
- if (end->interp == interp) {
+ if (end->interpid == interpid) {
break;
}
prev = end;
}
static _channelend *
-_channelends_add(_channelends *ends, _channelend *prev, int64_t interp,
+_channelends_add(_channelends *ends, _channelend *prev, int64_t interpid,
int send)
{
- _channelend *end = _channelend_new(interp);
+ _channelend *end = _channelend_new(interpid);
if (end == NULL) {
return NULL;
}
}
static int
-_channelends_associate(_channelends *ends, int64_t interp, int send)
+_channelends_associate(_channelends *ends, int64_t interpid, int send)
{
_channelend *prev;
_channelend *end = _channelend_find(send ? ends->send : ends->recv,
- interp, &prev);
+ interpid, &prev);
if (end != NULL) {
if (!end->open) {
return ERR_CHANNEL_CLOSED;
// already associated
return 0;
}
- if (_channelends_add(ends, prev, interp, send) == NULL) {
+ if (_channelends_add(ends, prev, interpid, send) == NULL) {
return -1;
}
return 0;
_channelends_is_open(_channelends *ends)
{
if (ends->numsendopen != 0 || ends->numrecvopen != 0) {
+ // At least one interpreter is still associated with the channel
+ // (and hasn't been released).
return 1;
}
+ // XXX This is wrong if an end can ever be removed.
if (ends->send == NULL && ends->recv == NULL) {
+ // The channel has never had any interpreters associated with it.
return 1;
}
return 0;
}
static void
-_channelends_close_end(_channelends *ends, _channelend *end, int send)
+_channelends_release_end(_channelends *ends, _channelend *end, int send)
{
end->open = 0;
if (send) {
}
static int
-_channelends_close_interpreter(_channelends *ends, int64_t interp, int which)
+_channelends_release_interpreter(_channelends *ends, int64_t interpid, int which)
{
_channelend *prev;
_channelend *end;
if (which >= 0) { // send/both
- end = _channelend_find(ends->send, interp, &prev);
+ end = _channelend_find(ends->send, interpid, &prev);
if (end == NULL) {
// never associated so add it
- end = _channelends_add(ends, prev, interp, 1);
+ end = _channelends_add(ends, prev, interpid, 1);
if (end == NULL) {
return -1;
}
}
- _channelends_close_end(ends, end, 1);
+ _channelends_release_end(ends, end, 1);
}
if (which <= 0) { // recv/both
- end = _channelend_find(ends->recv, interp, &prev);
+ end = _channelend_find(ends->recv, interpid, &prev);
if (end == NULL) {
// never associated so add it
- end = _channelends_add(ends, prev, interp, 0);
+ end = _channelends_add(ends, prev, interpid, 0);
if (end == NULL) {
return -1;
}
}
- _channelends_close_end(ends, end, 0);
+ _channelends_release_end(ends, end, 0);
}
return 0;
}
static void
-_channelends_drop_interpreter(_channelends *ends, int64_t interp)
-{
- _channelend *end;
- end = _channelend_find(ends->send, interp, NULL);
- if (end != NULL) {
- _channelends_close_end(ends, end, 1);
- }
- end = _channelend_find(ends->recv, interp, NULL);
- if (end != NULL) {
- _channelends_close_end(ends, end, 0);
- }
-}
-
-static void
-_channelends_close_all(_channelends *ends, int which, int force)
+_channelends_release_all(_channelends *ends, int which, int force)
{
// XXX Handle the ends.
// XXX Handle force is True.
// Ensure all the "send"-associated interpreters are closed.
_channelend *end;
for (end = ends->send; end != NULL; end = end->next) {
- _channelends_close_end(ends, end, 1);
+ _channelends_release_end(ends, end, 1);
}
// Ensure all the "recv"-associated interpreters are closed.
for (end = ends->recv; end != NULL; end = end->next) {
- _channelends_close_end(ends, end, 0);
+ _channelends_release_end(ends, end, 0);
}
}
-/* channels */
+static void
+_channelends_clear_interpreter(_channelends *ends, int64_t interpid)
+{
+ // XXX Actually remove the entries?
+ _channelend *end;
+ end = _channelend_find(ends->send, interpid, NULL);
+ if (end != NULL) {
+ _channelends_release_end(ends, end, 1);
+ }
+ end = _channelend_find(ends->recv, interpid, NULL);
+ if (end != NULL) {
+ _channelends_release_end(ends, end, 0);
+ }
+}
+
+
+/* each channel's state */
struct _channel;
struct _channel_closing;
_channelends *ends;
int open;
struct _channel_closing *closing;
-} _PyChannelState;
+} _channel_state;
-static _PyChannelState *
+static _channel_state *
_channel_new(PyThread_type_lock mutex)
{
- _PyChannelState *chan = GLOBAL_MALLOC(_PyChannelState);
+ _channel_state *chan = GLOBAL_MALLOC(_channel_state);
if (chan == NULL) {
return NULL;
}
}
static void
-_channel_free(_PyChannelState *chan)
+_channel_free(_channel_state *chan)
{
_channel_clear_closing(chan);
PyThread_acquire_lock(chan->mutex, WAIT_LOCK);
}
static int
-_channel_add(_PyChannelState *chan, int64_t interp,
+_channel_add(_channel_state *chan, int64_t interpid,
_PyCrossInterpreterData *data, _waiting_t *waiting)
{
int res = -1;
res = ERR_CHANNEL_CLOSED;
goto done;
}
- if (_channelends_associate(chan->ends, interp, 1) != 0) {
+ if (_channelends_associate(chan->ends, interpid, 1) != 0) {
res = ERR_CHANNEL_INTERP_CLOSED;
goto done;
}
}
static int
-_channel_next(_PyChannelState *chan, int64_t interp,
+_channel_next(_channel_state *chan, int64_t interpid,
_PyCrossInterpreterData **p_data, _waiting_t **p_waiting)
{
int err = 0;
err = ERR_CHANNEL_CLOSED;
goto done;
}
- if (_channelends_associate(chan->ends, interp, 0) != 0) {
+ if (_channelends_associate(chan->ends, interpid, 0) != 0) {
err = ERR_CHANNEL_INTERP_CLOSED;
goto done;
}
}
static void
-_channel_remove(_PyChannelState *chan, _channelitem_id_t itemid)
+_channel_remove(_channel_state *chan, _channelitem_id_t itemid)
{
_PyCrossInterpreterData *data = NULL;
_waiting_t *waiting = NULL;
}
static int
-_channel_close_interpreter(_PyChannelState *chan, int64_t interp, int end)
+_channel_release_interpreter(_channel_state *chan, int64_t interpid, int end)
{
PyThread_acquire_lock(chan->mutex, WAIT_LOCK);
goto done;
}
- if (_channelends_close_interpreter(chan->ends, interp, end) != 0) {
+ if (_channelends_release_interpreter(chan->ends, interpid, end) != 0) {
goto done;
}
chan->open = _channelends_is_open(chan->ends);
+ // XXX Clear the queue if not empty?
+ // XXX Activate the "closing" mechanism?
res = 0;
done:
return res;
}
-static void
-_channel_drop_interpreter(_PyChannelState *chan, int64_t interp)
-{
- PyThread_acquire_lock(chan->mutex, WAIT_LOCK);
-
- _channelqueue_drop_interpreter(chan->queue, interp);
- _channelends_drop_interpreter(chan->ends, interp);
- chan->open = _channelends_is_open(chan->ends);
-
- PyThread_release_lock(chan->mutex);
-}
-
static int
-_channel_close_all(_PyChannelState *chan, int end, int force)
+_channel_release_all(_channel_state *chan, int end, int force)
{
int res = -1;
PyThread_acquire_lock(chan->mutex, WAIT_LOCK);
res = ERR_CHANNEL_NOT_EMPTY;
goto done;
}
+ // XXX Clear the queue?
chan->open = 0;
// We *could* also just leave these in place, since we've marked
// the channel as closed already.
- _channelends_close_all(chan->ends, end, force);
+ _channelends_release_all(chan->ends, end, force);
res = 0;
done:
return res;
}
+static void
+_channel_clear_interpreter(_channel_state *chan, int64_t interpid)
+{
+ PyThread_acquire_lock(chan->mutex, WAIT_LOCK);
+
+ _channelqueue_clear_interpreter(chan->queue, interpid);
+ _channelends_clear_interpreter(chan->ends, interpid);
+ chan->open = _channelends_is_open(chan->ends);
+
+ PyThread_release_lock(chan->mutex);
+}
+
+
/* the set of channels */
struct _channelref;
typedef struct _channelref {
- int64_t id;
- _PyChannelState *chan;
+ int64_t cid;
+ _channel_state *chan;
struct _channelref *next;
+ // The number of ChannelID objects referring to this channel.
Py_ssize_t objcount;
} _channelref;
static _channelref *
-_channelref_new(int64_t id, _PyChannelState *chan)
+_channelref_new(int64_t cid, _channel_state *chan)
{
_channelref *ref = GLOBAL_MALLOC(_channelref);
if (ref == NULL) {
return NULL;
}
- ref->id = id;
+ ref->cid = cid;
ref->chan = chan;
ref->next = NULL;
ref->objcount = 0;
//static void
//_channelref_clear(_channelref *ref)
//{
-// ref->id = -1;
+// ref->cid = -1;
// ref->chan = NULL;
// ref->next = NULL;
// ref->objcount = 0;
}
static _channelref *
-_channelref_find(_channelref *first, int64_t id, _channelref **pprev)
+_channelref_find(_channelref *first, int64_t cid, _channelref **pprev)
{
_channelref *prev = NULL;
_channelref *ref = first;
while (ref != NULL) {
- if (ref->id == id) {
+ if (ref->cid == cid) {
break;
}
prev = ref;
return ref;
}
+
typedef struct _channels {
PyThread_type_lock mutex;
_channelref *head;
static int64_t
_channels_next_id(_channels *channels) // needs lock
{
- int64_t id = channels->next_id;
- if (id < 0) {
+ int64_t cid = channels->next_id;
+ if (cid < 0) {
/* overflow */
return -1;
}
channels->next_id += 1;
- return id;
+ return cid;
}
static int
-_channels_lookup(_channels *channels, int64_t id, PyThread_type_lock *pmutex,
- _PyChannelState **res)
+_channels_lookup(_channels *channels, int64_t cid, PyThread_type_lock *pmutex,
+ _channel_state **res)
{
int err = -1;
- _PyChannelState *chan = NULL;
+ _channel_state *chan = NULL;
PyThread_acquire_lock(channels->mutex, WAIT_LOCK);
if (pmutex != NULL) {
*pmutex = NULL;
}
- _channelref *ref = _channelref_find(channels->head, id, NULL);
+ _channelref *ref = _channelref_find(channels->head, cid, NULL);
if (ref == NULL) {
err = ERR_CHANNEL_NOT_FOUND;
goto done;
}
static int64_t
-_channels_add(_channels *channels, _PyChannelState *chan)
+_channels_add(_channels *channels, _channel_state *chan)
{
int64_t cid = -1;
PyThread_acquire_lock(channels->mutex, WAIT_LOCK);
// Create a new ref.
- int64_t id = _channels_next_id(channels);
- if (id < 0) {
+ int64_t _cid = _channels_next_id(channels);
+ if (_cid < 0) {
cid = ERR_NO_NEXT_CHANNEL_ID;
goto done;
}
- _channelref *ref = _channelref_new(id, chan);
+ _channelref *ref = _channelref_new(_cid, chan);
if (ref == NULL) {
goto done;
}
channels->head = ref;
channels->numopen += 1;
- cid = id;
+ cid = _cid;
done:
PyThread_release_lock(channels->mutex);
return cid;
}
/* forward */
-static int _channel_set_closing(struct _channelref *, PyThread_type_lock);
+static int _channel_set_closing(_channelref *, PyThread_type_lock);
static int
-_channels_close(_channels *channels, int64_t cid, _PyChannelState **pchan,
+_channels_close(_channels *channels, int64_t cid, _channel_state **pchan,
int end, int force)
{
int res = -1;
goto done;
}
else {
- int err = _channel_close_all(ref->chan, end, force);
+ int err = _channel_release_all(ref->chan, end, force);
if (err != 0) {
if (end == CHANNEL_SEND && err == ERR_CHANNEL_NOT_EMPTY) {
if (ref->chan->closing != NULL) {
static void
_channels_remove_ref(_channels *channels, _channelref *ref, _channelref *prev,
- _PyChannelState **pchan)
+ _channel_state **pchan)
{
if (ref == channels->head) {
channels->head = ref->next;
}
static int
-_channels_remove(_channels *channels, int64_t id, _PyChannelState **pchan)
+_channels_remove(_channels *channels, int64_t cid, _channel_state **pchan)
{
int res = -1;
PyThread_acquire_lock(channels->mutex, WAIT_LOCK);
}
_channelref *prev = NULL;
- _channelref *ref = _channelref_find(channels->head, id, &prev);
+ _channelref *ref = _channelref_find(channels->head, cid, &prev);
if (ref == NULL) {
res = ERR_CHANNEL_NOT_FOUND;
goto done;
}
static int
-_channels_add_id_object(_channels *channels, int64_t id)
+_channels_add_id_object(_channels *channels, int64_t cid)
{
int res = -1;
PyThread_acquire_lock(channels->mutex, WAIT_LOCK);
- _channelref *ref = _channelref_find(channels->head, id, NULL);
+ _channelref *ref = _channelref_find(channels->head, cid, NULL);
if (ref == NULL) {
res = ERR_CHANNEL_NOT_FOUND;
goto done;
}
static void
-_channels_drop_id_object(_channels *channels, int64_t id)
+_channels_release_cid_object(_channels *channels, int64_t cid)
{
PyThread_acquire_lock(channels->mutex, WAIT_LOCK);
_channelref *prev = NULL;
- _channelref *ref = _channelref_find(channels->head, id, &prev);
+ _channelref *ref = _channelref_find(channels->head, cid, &prev);
if (ref == NULL) {
// Already destroyed.
goto done;
// Destroy if no longer used.
if (ref->objcount == 0) {
- _PyChannelState *chan = NULL;
+ _channel_state *chan = NULL;
_channels_remove_ref(channels, ref, prev, &chan);
if (chan != NULL) {
_channel_free(chan);
}
_channelref *ref = channels->head;
for (int64_t i=0; ref != NULL; ref = ref->next, i++) {
- ids[i] = ref->id;
+ ids[i] = ref->cid;
}
*count = channels->numopen;
}
static void
-_channels_drop_interpreter(_channels *channels, int64_t interp)
+_channels_clear_interpreter(_channels *channels, int64_t interpid)
{
PyThread_acquire_lock(channels->mutex, WAIT_LOCK);
_channelref *ref = channels->head;
for (; ref != NULL; ref = ref->next) {
if (ref->chan != NULL) {
- _channel_drop_interpreter(ref->chan, interp);
+ _channel_clear_interpreter(ref->chan, interpid);
}
}
PyThread_release_lock(channels->mutex);
}
+
/* support for closing non-empty channels */
struct _channel_closing {
- struct _channelref *ref;
+ _channelref *ref;
};
static int
-_channel_set_closing(struct _channelref *ref, PyThread_type_lock mutex) {
- struct _channel *chan = ref->chan;
+_channel_set_closing(_channelref *ref, PyThread_type_lock mutex) {
+ _channel_state *chan = ref->chan;
if (chan == NULL) {
// already closed
return 0;
}
static void
-_channel_clear_closing(struct _channel *chan) {
+_channel_clear_closing(_channel_state *chan) {
PyThread_acquire_lock(chan->mutex, WAIT_LOCK);
if (chan->closing != NULL) {
GLOBAL_FREE(chan->closing);
}
static void
-_channel_finish_closing(struct _channel *chan) {
+_channel_finish_closing(_channel_state *chan) {
struct _channel_closing *closing = chan->closing;
if (closing == NULL) {
return;
_channel_free(chan);
}
+
/* "high"-level channel-related functions */
+// Create a new channel.
static int64_t
-_channel_create(_channels *channels)
+channel_create(_channels *channels)
{
PyThread_type_lock mutex = PyThread_allocate_lock();
if (mutex == NULL) {
return ERR_CHANNEL_MUTEX_INIT;
}
- _PyChannelState *chan = _channel_new(mutex);
+ _channel_state *chan = _channel_new(mutex);
if (chan == NULL) {
PyThread_free_lock(mutex);
return -1;
}
- int64_t id = _channels_add(channels, chan);
- if (id < 0) {
+ int64_t cid = _channels_add(channels, chan);
+ if (cid < 0) {
_channel_free(chan);
}
- return id;
+ return cid;
}
+// Completely destroy the channel.
static int
-_channel_destroy(_channels *channels, int64_t id)
+channel_destroy(_channels *channels, int64_t cid)
{
- _PyChannelState *chan = NULL;
- int err = _channels_remove(channels, id, &chan);
+ _channel_state *chan = NULL;
+ int err = _channels_remove(channels, cid, &chan);
if (err != 0) {
return err;
}
return 0;
}
+// Push an object onto the channel.
+// The current interpreter gets associated with the send end of the channel.
+// Optionally request to be notified when it is received.
static int
-_channel_send(_channels *channels, int64_t id, PyObject *obj,
- _waiting_t *waiting)
+channel_send(_channels *channels, int64_t cid, PyObject *obj,
+ _waiting_t *waiting)
{
PyInterpreterState *interp = _get_current_interp();
if (interp == NULL) {
return -1;
}
+ int64_t interpid = PyInterpreterState_GetID(interp);
// Look up the channel.
PyThread_type_lock mutex = NULL;
- _PyChannelState *chan = NULL;
- int err = _channels_lookup(channels, id, &mutex, &chan);
+ _channel_state *chan = NULL;
+ int err = _channels_lookup(channels, cid, &mutex, &chan);
if (err != 0) {
return err;
}
}
// Add the data to the channel.
- int res = _channel_add(chan, PyInterpreterState_GetID(interp),
- data, waiting);
+ int res = _channel_add(chan, interpid, data, waiting);
PyThread_release_lock(mutex);
if (res != 0) {
// We may chain an exception here:
return 0;
}
+// Basically, un-send an object.
static void
-_channel_clear_sent(_channels *channels, int64_t cid, _waiting_t *waiting)
+channel_clear_sent(_channels *channels, int64_t cid, _waiting_t *waiting)
{
// Look up the channel.
PyThread_type_lock mutex = NULL;
- _PyChannelState *chan = NULL;
+ _channel_state *chan = NULL;
int err = _channels_lookup(channels, cid, &mutex, &chan);
if (err != 0) {
// The channel was already closed, etc.
PyThread_release_lock(mutex);
}
+// Like channel_send(), but strictly wait for the object to be received.
static int
-_channel_send_wait(_channels *channels, int64_t cid, PyObject *obj,
+channel_send_wait(_channels *channels, int64_t cid, PyObject *obj,
PY_TIMEOUT_T timeout)
{
// We use a stack variable here, so we must ensure that &waiting
}
/* Queue up the object. */
- int res = _channel_send(channels, cid, obj, &waiting);
+ int res = channel_send(channels, cid, obj, &waiting);
if (res < 0) {
assert(waiting.status == WAITING_NO_STATUS);
goto finally;
_waiting_finish_releasing(&waiting);
/* The send() call is failing now, so make sure the item
won't be received. */
- _channel_clear_sent(channels, cid, &waiting);
+ channel_clear_sent(channels, cid, &waiting);
assert(waiting.status == WAITING_RELEASED);
if (!waiting.received) {
res = -1;
return res;
}
+// Pop the next object off the channel. Fail if empty.
+// The current interpreter gets associated with the recv end of the channel.
+// XXX Support a "wait" mutex?
static int
-_channel_recv(_channels *channels, int64_t id, PyObject **res)
+channel_recv(_channels *channels, int64_t cid, PyObject **res)
{
int err;
*res = NULL;
}
return 0;
}
+ int64_t interpid = PyInterpreterState_GetID(interp);
// Look up the channel.
PyThread_type_lock mutex = NULL;
- _PyChannelState *chan = NULL;
- err = _channels_lookup(channels, id, &mutex, &chan);
+ _channel_state *chan = NULL;
+ err = _channels_lookup(channels, cid, &mutex, &chan);
if (err != 0) {
return err;
}
// Pop off the next item from the channel.
_PyCrossInterpreterData *data = NULL;
_waiting_t *waiting = NULL;
- err = _channel_next(chan, PyInterpreterState_GetID(interp), &data,
- &waiting);
+ err = _channel_next(chan, interpid, &data, &waiting);
PyThread_release_lock(mutex);
if (err != 0) {
return err;
PyObject *obj = _PyCrossInterpreterData_NewObject(data);
if (obj == NULL) {
assert(PyErr_Occurred());
- // It was allocated in _channel_send(), so we free it.
+ // It was allocated in channel_send(), so we free it.
(void)_release_xid_data(data, XID_IGNORE_EXC | XID_FREE);
if (waiting != NULL) {
_waiting_release(waiting, 0);
}
return -1;
}
- // It was allocated in _channel_send(), so we free it.
+ // It was allocated in channel_send(), so we free it.
int release_res = _release_xid_data(data, XID_FREE);
if (release_res < 0) {
// The source interpreter has been destroyed already.
return 0;
}
+// Disallow send/recv for the current interpreter.
+// The channel is marked as closed if no other interpreters
+// are currently associated.
static int
-_channel_drop(_channels *channels, int64_t id, int send, int recv)
+channel_release(_channels *channels, int64_t cid, int send, int recv)
{
PyInterpreterState *interp = _get_current_interp();
if (interp == NULL) {
return -1;
}
+ int64_t interpid = PyInterpreterState_GetID(interp);
// Look up the channel.
PyThread_type_lock mutex = NULL;
- _PyChannelState *chan = NULL;
- int err = _channels_lookup(channels, id, &mutex, &chan);
+ _channel_state *chan = NULL;
+ int err = _channels_lookup(channels, cid, &mutex, &chan);
if (err != 0) {
return err;
}
// Past this point we are responsible for releasing the mutex.
// Close one or both of the two ends.
- int res = _channel_close_interpreter(chan, PyInterpreterState_GetID(interp), send-recv);
+ int res = _channel_release_interpreter(chan, interpid, send-recv);
PyThread_release_lock(mutex);
return res;
}
+// Close the channel (for all interpreters). Fail if it's already closed.
+// Close immediately if it's empty. Otherwise, disallow sending and
+// finally close once empty. Optionally, immediately clear and close it.
static int
-_channel_close(_channels *channels, int64_t id, int end, int force)
+channel_close(_channels *channels, int64_t cid, int end, int force)
{
- return _channels_close(channels, id, NULL, end, force);
+ return _channels_close(channels, cid, NULL, end, force);
}
+// Return true if the identified interpreter is associated
+// with the given end of the channel.
static int
-_channel_is_associated(_channels *channels, int64_t cid, int64_t interp,
+channel_is_associated(_channels *channels, int64_t cid, int64_t interpid,
int send)
{
- _PyChannelState *chan = NULL;
+ _channel_state *chan = NULL;
int err = _channels_lookup(channels, cid, NULL, &chan);
if (err != 0) {
return err;
}
_channelend *end = _channelend_find(send ? chan->ends->send : chan->ends->recv,
- interp, NULL);
+ interpid, NULL);
return (end != NULL && end->open);
}
+
/* ChannelID class */
typedef struct channelid {
PyObject_HEAD
- int64_t id;
+ int64_t cid;
int end;
int resolve;
_channels *channels;
module_state *state = get_module_state(data->module);
assert(state != NULL);
if (PyObject_TypeCheck(arg, state->ChannelIDType)) {
- cid = ((channelid *)arg)->id;
+ cid = ((channelid *)arg)->cid;
end = ((channelid *)arg)->end;
}
else if (PyIndex_Check(arg)) {
if (self == NULL) {
return -1;
}
- self->id = cid;
+ self->cid = cid;
self->end = end;
self->resolve = resolve;
self->channels = channels;
end = CHANNEL_RECV;
}
- PyObject *id = NULL;
+ PyObject *cidobj = NULL;
int err = newchannelid(cls, cid, end, _global_channels(),
force, resolve,
- (channelid **)&id);
+ (channelid **)&cidobj);
if (handle_channel_error(err, mod, cid)) {
- assert(id == NULL);
+ assert(cidobj == NULL);
return NULL;
}
- assert(id != NULL);
- return id;
+ assert(cidobj != NULL);
+ return cidobj;
}
static void
channelid_dealloc(PyObject *self)
{
- int64_t cid = ((channelid *)self)->id;
+ int64_t cid = ((channelid *)self)->cid;
_channels *channels = ((channelid *)self)->channels;
PyTypeObject *tp = Py_TYPE(self);
// like we do for _abc._abc_data?
Py_DECREF(tp);
- _channels_drop_id_object(channels, cid);
+ _channels_release_cid_object(channels, cid);
}
static PyObject *
PyTypeObject *type = Py_TYPE(self);
const char *name = _PyType_Name(type);
- channelid *cid = (channelid *)self;
+ channelid *cidobj = (channelid *)self;
const char *fmt;
- if (cid->end == CHANNEL_SEND) {
+ if (cidobj->end == CHANNEL_SEND) {
fmt = "%s(%" PRId64 ", send=True)";
}
- else if (cid->end == CHANNEL_RECV) {
+ else if (cidobj->end == CHANNEL_RECV) {
fmt = "%s(%" PRId64 ", recv=True)";
}
else {
fmt = "%s(%" PRId64 ")";
}
- return PyUnicode_FromFormat(fmt, name, cid->id);
+ return PyUnicode_FromFormat(fmt, name, cidobj->cid);
}
static PyObject *
channelid_str(PyObject *self)
{
- channelid *cid = (channelid *)self;
- return PyUnicode_FromFormat("%" PRId64 "", cid->id);
+ channelid *cidobj = (channelid *)self;
+ return PyUnicode_FromFormat("%" PRId64 "", cidobj->cid);
}
static PyObject *
channelid_int(PyObject *self)
{
- channelid *cid = (channelid *)self;
- return PyLong_FromLongLong(cid->id);
+ channelid *cidobj = (channelid *)self;
+ return PyLong_FromLongLong(cidobj->cid);
}
static Py_hash_t
channelid_hash(PyObject *self)
{
- channelid *cid = (channelid *)self;
- PyObject *id = PyLong_FromLongLong(cid->id);
- if (id == NULL) {
+ channelid *cidobj = (channelid *)self;
+ PyObject *pyid = PyLong_FromLongLong(cidobj->cid);
+ if (pyid == NULL) {
return -1;
}
- Py_hash_t hash = PyObject_Hash(id);
- Py_DECREF(id);
+ Py_hash_t hash = PyObject_Hash(pyid);
+ Py_DECREF(pyid);
return hash;
}
goto done;
}
- channelid *cid = (channelid *)self;
+ channelid *cidobj = (channelid *)self;
int equal;
if (PyObject_TypeCheck(other, state->ChannelIDType)) {
- channelid *othercid = (channelid *)other;
- equal = (cid->end == othercid->end) && (cid->id == othercid->id);
+ channelid *othercidobj = (channelid *)other;
+ equal = (cidobj->end == othercidobj->end) && (cidobj->cid == othercidobj->cid);
}
else if (PyLong_Check(other)) {
/* Fast path */
if (othercid == -1 && PyErr_Occurred()) {
goto done;
}
- equal = !overflow && (othercid >= 0) && (cid->id == othercid);
+ equal = !overflow && (othercid >= 0) && (cidobj->cid == othercid);
}
else if (PyNumber_Check(other)) {
- PyObject *pyid = PyLong_FromLongLong(cid->id);
+ PyObject *pyid = PyLong_FromLongLong(cidobj->cid);
if (pyid == NULL) {
goto done;
}
return res;
}
-static PyTypeObject * _get_current_channel_end_type(int end);
+static PyTypeObject * _get_current_channelend_type(int end);
static PyObject *
-_channel_from_cid(PyObject *cid, int end)
+_channelobj_from_cidobj(PyObject *cidobj, int end)
{
- PyObject *cls = (PyObject *)_get_current_channel_end_type(end);
+ PyObject *cls = (PyObject *)_get_current_channelend_type(end);
if (cls == NULL) {
return NULL;
}
- PyObject *chan = PyObject_CallFunctionObjArgs(cls, cid, NULL);
+ PyObject *chan = PyObject_CallFunctionObjArgs(cls, cidobj, NULL);
Py_DECREF(cls);
if (chan == NULL) {
return NULL;
}
struct _channelid_xid {
- int64_t id;
+ int64_t cid;
int end;
int resolve;
};
}
// Note that we do not preserve the "resolve" flag.
- PyObject *cid = NULL;
- int err = newchannelid(state->ChannelIDType, xid->id, xid->end,
+ PyObject *cidobj = NULL;
+ int err = newchannelid(state->ChannelIDType, xid->cid, xid->end,
_global_channels(), 0, 0,
- (channelid **)&cid);
+ (channelid **)&cidobj);
if (err != 0) {
- assert(cid == NULL);
- (void)handle_channel_error(err, mod, xid->id);
+ assert(cidobj == NULL);
+ (void)handle_channel_error(err, mod, xid->cid);
goto done;
}
- assert(cid != NULL);
+ assert(cidobj != NULL);
if (xid->end == 0) {
goto done;
}
}
/* Try returning a high-level channel end but fall back to the ID. */
- PyObject *chan = _channel_from_cid(cid, xid->end);
+ PyObject *chan = _channelobj_from_cidobj(cidobj, xid->end);
if (chan == NULL) {
PyErr_Clear();
goto done;
}
- Py_DECREF(cid);
- cid = chan;
+ Py_DECREF(cidobj);
+ cidobj = chan;
done:
Py_DECREF(mod);
- return cid;
+ return cidobj;
}
static int
return -1;
}
struct _channelid_xid *xid = (struct _channelid_xid *)data->data;
- xid->id = ((channelid *)obj)->id;
+ xid->cid = ((channelid *)obj)->cid;
xid->end = ((channelid *)obj)->end;
xid->resolve = ((channelid *)obj)->resolve;
return 0;
channelid_end(PyObject *self, void *end)
{
int force = 1;
- channelid *cid = (channelid *)self;
+ channelid *cidobj = (channelid *)self;
if (end != NULL) {
- PyObject *id = NULL;
- int err = newchannelid(Py_TYPE(self), cid->id, *(int *)end,
- cid->channels, force, cid->resolve,
- (channelid **)&id);
+ PyObject *obj = NULL;
+ int err = newchannelid(Py_TYPE(self), cidobj->cid, *(int *)end,
+ cidobj->channels, force, cidobj->resolve,
+ (channelid **)&obj);
if (err != 0) {
- assert(id == NULL);
+ assert(obj == NULL);
PyObject *mod = get_module_from_type(Py_TYPE(self));
if (mod == NULL) {
return NULL;
}
- (void)handle_channel_error(err, mod, cid->id);
+ (void)handle_channel_error(err, mod, cidobj->cid);
Py_DECREF(mod);
return NULL;
}
- assert(id != NULL);
- return id;
+ assert(obj != NULL);
+ return obj;
}
- if (cid->end == CHANNEL_SEND) {
+ if (cidobj->end == CHANNEL_SEND) {
return PyUnicode_InternFromString("send");
}
- if (cid->end == CHANNEL_RECV) {
+ if (cidobj->end == CHANNEL_RECV) {
return PyUnicode_InternFromString("recv");
}
return PyUnicode_InternFromString("both");
PyDoc_STRVAR(channelid_doc,
"A channel ID identifies a channel and may be used as an int.");
-static PyType_Slot ChannelIDType_slots[] = {
+static PyType_Slot channelid_typeslots[] = {
{Py_tp_dealloc, (destructor)channelid_dealloc},
{Py_tp_doc, (void *)channelid_doc},
{Py_tp_repr, (reprfunc)channelid_repr},
{0, NULL},
};
-static PyType_Spec ChannelIDType_spec = {
+static PyType_Spec channelid_typespec = {
.name = MODULE_NAME ".ChannelID",
.basicsize = sizeof(channelid),
.flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE |
Py_TPFLAGS_DISALLOW_INSTANTIATION | Py_TPFLAGS_IMMUTABLETYPE),
- .slots = ChannelIDType_slots,
+ .slots = channelid_typeslots,
};
// XXX Use a new __xid__ protocol instead?
static PyTypeObject *
-_get_current_channel_end_type(int end)
+_get_current_channelend_type(int end)
{
module_state *state = _get_current_module_state();
if (state == NULL) {
}
static PyObject *
-_channel_end_from_xid(_PyCrossInterpreterData *data)
+_channelend_from_xid(_PyCrossInterpreterData *data)
{
- channelid *cid = (channelid *)_channelid_from_xid(data);
- if (cid == NULL) {
+ channelid *cidobj = (channelid *)_channelid_from_xid(data);
+ if (cidobj == NULL) {
return NULL;
}
- PyTypeObject *cls = _get_current_channel_end_type(cid->end);
+ PyTypeObject *cls = _get_current_channelend_type(cidobj->end);
if (cls == NULL) {
- Py_DECREF(cid);
+ Py_DECREF(cidobj);
return NULL;
}
- PyObject *obj = PyObject_CallOneArg((PyObject *)cls, (PyObject *)cid);
- Py_DECREF(cid);
+ PyObject *obj = PyObject_CallOneArg((PyObject *)cls, (PyObject *)cidobj);
+ Py_DECREF(cidobj);
return obj;
}
static int
-_channel_end_shared(PyThreadState *tstate, PyObject *obj,
+_channelend_shared(PyThreadState *tstate, PyObject *obj,
_PyCrossInterpreterData *data)
{
PyObject *cidobj = PyObject_GetAttrString(obj, "_id");
if (res < 0) {
return -1;
}
- data->new_object = _channel_end_from_xid;
+ data->new_object = _channelend_from_xid;
return 0;
}
static int
-set_channel_end_types(PyObject *mod, PyTypeObject *send, PyTypeObject *recv)
+set_channelend_types(PyObject *mod, PyTypeObject *send, PyTypeObject *recv)
{
module_state *state = get_module_state(mod);
if (state == NULL) {
state->send_channel_type = (PyTypeObject *)Py_NewRef(send);
state->recv_channel_type = (PyTypeObject *)Py_NewRef(recv);
- if (register_xid_class(send, _channel_end_shared, xid_classes)) {
+ if (register_xid_class(send, _channelend_shared, xid_classes)) {
return -1;
}
- if (register_xid_class(recv, _channel_end_shared, xid_classes)) {
+ if (register_xid_class(recv, _channelend_shared, xid_classes)) {
return -1;
}
return 0;
}
+
/* module level code ********************************************************/
/* globals is the process-global state for the module. It holds all
}
PyInterpreterState *interp = (PyInterpreterState *)data;
assert(interp == _get_current_interp());
- int64_t id = PyInterpreterState_GetID(interp);
- _channels_drop_interpreter(&_globals.channels, id);
+ int64_t interpid = PyInterpreterState_GetID(interp);
+ _channels_clear_interpreter(&_globals.channels, interpid);
}
static PyObject *
-channel_create(PyObject *self, PyObject *Py_UNUSED(ignored))
+channelsmod_create(PyObject *self, PyObject *Py_UNUSED(ignored))
{
- int64_t cid = _channel_create(&_globals.channels);
+ int64_t cid = channel_create(&_globals.channels);
if (cid < 0) {
(void)handle_channel_error(-1, self, cid);
return NULL;
if (state == NULL) {
return NULL;
}
- PyObject *id = NULL;
+ PyObject *cidobj = NULL;
int err = newchannelid(state->ChannelIDType, cid, 0,
&_globals.channels, 0, 0,
- (channelid **)&id);
+ (channelid **)&cidobj);
if (handle_channel_error(err, self, cid)) {
- assert(id == NULL);
- err = _channel_destroy(&_globals.channels, cid);
+ assert(cidobj == NULL);
+ err = channel_destroy(&_globals.channels, cid);
if (handle_channel_error(err, self, cid)) {
// XXX issue a warning?
}
return NULL;
}
- assert(id != NULL);
- assert(((channelid *)id)->channels != NULL);
- return id;
+ assert(cidobj != NULL);
+ assert(((channelid *)cidobj)->channels != NULL);
+ return cidobj;
}
-PyDoc_STRVAR(channel_create_doc,
+PyDoc_STRVAR(channelsmod_create_doc,
"channel_create() -> cid\n\
\n\
Create a new cross-interpreter channel and return a unique generated ID.");
static PyObject *
-channel_destroy(PyObject *self, PyObject *args, PyObject *kwds)
+channelsmod_destroy(PyObject *self, PyObject *args, PyObject *kwds)
{
static char *kwlist[] = {"cid", NULL};
int64_t cid;
}
cid = cid_data.cid;
- int err = _channel_destroy(&_globals.channels, cid);
+ int err = channel_destroy(&_globals.channels, cid);
if (handle_channel_error(err, self, cid)) {
return NULL;
}
Py_RETURN_NONE;
}
-PyDoc_STRVAR(channel_destroy_doc,
+PyDoc_STRVAR(channelsmod_destroy_doc,
"channel_destroy(cid)\n\
\n\
Close and finalize the channel. Afterward attempts to use the channel\n\
will behave as though it never existed.");
static PyObject *
-channel_list_all(PyObject *self, PyObject *Py_UNUSED(ignored))
+channelsmod_list_all(PyObject *self, PyObject *Py_UNUSED(ignored))
{
int64_t count = 0;
int64_t *cids = _channels_list_all(&_globals.channels, &count);
}
int64_t *cur = cids;
for (int64_t i=0; i < count; cur++, i++) {
- PyObject *id = NULL;
+ PyObject *cidobj = NULL;
int err = newchannelid(state->ChannelIDType, *cur, 0,
&_globals.channels, 0, 0,
- (channelid **)&id);
+ (channelid **)&cidobj);
if (handle_channel_error(err, self, *cur)) {
- assert(id == NULL);
+ assert(cidobj == NULL);
Py_SETREF(ids, NULL);
break;
}
- assert(id != NULL);
- PyList_SET_ITEM(ids, (Py_ssize_t)i, id);
+ assert(cidobj != NULL);
+ PyList_SET_ITEM(ids, (Py_ssize_t)i, cidobj);
}
finally:
return ids;
}
-PyDoc_STRVAR(channel_list_all_doc,
+PyDoc_STRVAR(channelsmod_list_all_doc,
"channel_list_all() -> [cid]\n\
\n\
Return the list of all IDs for active channels.");
static PyObject *
-channel_list_interpreters(PyObject *self, PyObject *args, PyObject *kwds)
+channelsmod_list_interpreters(PyObject *self, PyObject *args, PyObject *kwds)
{
static char *kwlist[] = {"cid", "send", NULL};
int64_t cid; /* Channel ID */
.module = self,
};
int send = 0; /* Send or receive end? */
- int64_t id;
- PyObject *ids, *id_obj;
+ int64_t interpid;
+ PyObject *ids, *interpid_obj;
PyInterpreterState *interp;
if (!PyArg_ParseTupleAndKeywords(
interp = PyInterpreterState_Head();
while (interp != NULL) {
- id = PyInterpreterState_GetID(interp);
- assert(id >= 0);
- int res = _channel_is_associated(&_globals.channels, cid, id, send);
+ interpid = PyInterpreterState_GetID(interp);
+ assert(interpid >= 0);
+ int res = channel_is_associated(&_globals.channels, cid, interpid, send);
if (res < 0) {
(void)handle_channel_error(res, self, cid);
goto except;
}
if (res) {
- id_obj = PyInterpreterState_GetIDObject(interp);
- if (id_obj == NULL) {
+ interpid_obj = PyInterpreterState_GetIDObject(interp);
+ if (interpid_obj == NULL) {
goto except;
}
- res = PyList_Insert(ids, 0, id_obj);
- Py_DECREF(id_obj);
+ res = PyList_Insert(ids, 0, interpid_obj);
+ Py_DECREF(interpid_obj);
if (res < 0) {
goto except;
}
return ids;
}
-PyDoc_STRVAR(channel_list_interpreters_doc,
+PyDoc_STRVAR(channelsmod_list_interpreters_doc,
"channel_list_interpreters(cid, *, send) -> [id]\n\
\n\
Return the list of all interpreter IDs associated with an end of the channel.\n\
static PyObject *
-channel_send(PyObject *self, PyObject *args, PyObject *kwds)
+channelsmod_send(PyObject *self, PyObject *args, PyObject *kwds)
{
static char *kwlist[] = {"cid", "obj", "blocking", "timeout", NULL};
struct channel_id_converter_data cid_data = {
/* Queue up the object. */
int err = 0;
if (blocking) {
- err = _channel_send_wait(&_globals.channels, cid, obj, timeout);
+ err = channel_send_wait(&_globals.channels, cid, obj, timeout);
}
else {
- err = _channel_send(&_globals.channels, cid, obj, NULL);
+ err = channel_send(&_globals.channels, cid, obj, NULL);
}
if (handle_channel_error(err, self, cid)) {
return NULL;
Py_RETURN_NONE;
}
-PyDoc_STRVAR(channel_send_doc,
+PyDoc_STRVAR(channelsmod_send_doc,
"channel_send(cid, obj, blocking=True)\n\
\n\
Add the object's data to the channel's queue.\n\
By default this waits for the object to be received.");
static PyObject *
-channel_send_buffer(PyObject *self, PyObject *args, PyObject *kwds)
+channelsmod_send_buffer(PyObject *self, PyObject *args, PyObject *kwds)
{
static char *kwlist[] = {"cid", "obj", "blocking", "timeout", NULL};
struct channel_id_converter_data cid_data = {
/* Queue up the object. */
int err = 0;
if (blocking) {
- err = _channel_send_wait(&_globals.channels, cid, tempobj, timeout);
+ err = channel_send_wait(&_globals.channels, cid, tempobj, timeout);
}
else {
- err = _channel_send(&_globals.channels, cid, tempobj, NULL);
+ err = channel_send(&_globals.channels, cid, tempobj, NULL);
}
Py_DECREF(tempobj);
if (handle_channel_error(err, self, cid)) {
Py_RETURN_NONE;
}
-PyDoc_STRVAR(channel_send_buffer_doc,
+PyDoc_STRVAR(channelsmod_send_buffer_doc,
"channel_send_buffer(cid, obj, blocking=True)\n\
\n\
Add the object's buffer to the channel's queue.\n\
By default this waits for the object to be received.");
static PyObject *
-channel_recv(PyObject *self, PyObject *args, PyObject *kwds)
+channelsmod_recv(PyObject *self, PyObject *args, PyObject *kwds)
{
static char *kwlist[] = {"cid", "default", NULL};
int64_t cid;
cid = cid_data.cid;
PyObject *obj = NULL;
- int err = _channel_recv(&_globals.channels, cid, &obj);
+ int err = channel_recv(&_globals.channels, cid, &obj);
if (handle_channel_error(err, self, cid)) {
return NULL;
}
return obj;
}
-PyDoc_STRVAR(channel_recv_doc,
+PyDoc_STRVAR(channelsmod_recv_doc,
"channel_recv(cid, [default]) -> obj\n\
\n\
Return a new object from the data at the front of the channel's queue.\n\
a default value is provided. In that case return it.");
static PyObject *
-channel_close(PyObject *self, PyObject *args, PyObject *kwds)
+channelsmod_close(PyObject *self, PyObject *args, PyObject *kwds)
{
static char *kwlist[] = {"cid", "send", "recv", "force", NULL};
int64_t cid;
}
cid = cid_data.cid;
- int err = _channel_close(&_globals.channels, cid, send-recv, force);
+ int err = channel_close(&_globals.channels, cid, send-recv, force);
if (handle_channel_error(err, self, cid)) {
return NULL;
}
Py_RETURN_NONE;
}
-PyDoc_STRVAR(channel_close_doc,
+PyDoc_STRVAR(channelsmod_close_doc,
"channel_close(cid, *, send=None, recv=None, force=False)\n\
\n\
Close the channel for all interpreters.\n\
the channel will be destroyed.");
static PyObject *
-channel_release(PyObject *self, PyObject *args, PyObject *kwds)
+channelsmod_release(PyObject *self, PyObject *args, PyObject *kwds)
{
// Note that only the current interpreter is affected.
static char *kwlist[] = {"cid", "send", "recv", "force", NULL};
// XXX Handle force is True.
// XXX Fix implicit release.
- int err = _channel_drop(&_globals.channels, cid, send, recv);
+ int err = channel_release(&_globals.channels, cid, send, recv);
if (handle_channel_error(err, self, cid)) {
return NULL;
}
Py_RETURN_NONE;
}
-PyDoc_STRVAR(channel_release_doc,
+PyDoc_STRVAR(channelsmod_release_doc,
"channel_release(cid, *, send=None, recv=None, force=True)\n\
\n\
Close the channel for the current interpreter. 'send' and 'recv'\n\
ends are closed. Closing an already closed end is a noop.");
static PyObject *
-channel__channel_id(PyObject *self, PyObject *args, PyObject *kwds)
+channelsmod__channel_id(PyObject *self, PyObject *args, PyObject *kwds)
{
module_state *state = get_module_state(self);
if (state == NULL) {
}
static PyObject *
-channel__register_end_types(PyObject *self, PyObject *args, PyObject *kwds)
+channelsmod__register_end_types(PyObject *self, PyObject *args, PyObject *kwds)
{
static char *kwlist[] = {"send", "recv", NULL};
PyObject *send;
PyTypeObject *cls_send = (PyTypeObject *)send;
PyTypeObject *cls_recv = (PyTypeObject *)recv;
- if (set_channel_end_types(self, cls_send, cls_recv) < 0) {
+ if (set_channelend_types(self, cls_send, cls_recv) < 0) {
return NULL;
}
}
static PyMethodDef module_functions[] = {
- {"create", channel_create,
- METH_NOARGS, channel_create_doc},
- {"destroy", _PyCFunction_CAST(channel_destroy),
- METH_VARARGS | METH_KEYWORDS, channel_destroy_doc},
- {"list_all", channel_list_all,
- METH_NOARGS, channel_list_all_doc},
- {"list_interpreters", _PyCFunction_CAST(channel_list_interpreters),
- METH_VARARGS | METH_KEYWORDS, channel_list_interpreters_doc},
- {"send", _PyCFunction_CAST(channel_send),
- METH_VARARGS | METH_KEYWORDS, channel_send_doc},
- {"send_buffer", _PyCFunction_CAST(channel_send_buffer),
- METH_VARARGS | METH_KEYWORDS, channel_send_buffer_doc},
- {"recv", _PyCFunction_CAST(channel_recv),
- METH_VARARGS | METH_KEYWORDS, channel_recv_doc},
- {"close", _PyCFunction_CAST(channel_close),
- METH_VARARGS | METH_KEYWORDS, channel_close_doc},
- {"release", _PyCFunction_CAST(channel_release),
- METH_VARARGS | METH_KEYWORDS, channel_release_doc},
- {"_channel_id", _PyCFunction_CAST(channel__channel_id),
+ {"create", channelsmod_create,
+ METH_NOARGS, channelsmod_create_doc},
+ {"destroy", _PyCFunction_CAST(channelsmod_destroy),
+ METH_VARARGS | METH_KEYWORDS, channelsmod_destroy_doc},
+ {"list_all", channelsmod_list_all,
+ METH_NOARGS, channelsmod_list_all_doc},
+ {"list_interpreters", _PyCFunction_CAST(channelsmod_list_interpreters),
+ METH_VARARGS | METH_KEYWORDS, channelsmod_list_interpreters_doc},
+ {"send", _PyCFunction_CAST(channelsmod_send),
+ METH_VARARGS | METH_KEYWORDS, channelsmod_send_doc},
+ {"send_buffer", _PyCFunction_CAST(channelsmod_send_buffer),
+ METH_VARARGS | METH_KEYWORDS, channelsmod_send_buffer_doc},
+ {"recv", _PyCFunction_CAST(channelsmod_recv),
+ METH_VARARGS | METH_KEYWORDS, channelsmod_recv_doc},
+ {"close", _PyCFunction_CAST(channelsmod_close),
+ METH_VARARGS | METH_KEYWORDS, channelsmod_close_doc},
+ {"release", _PyCFunction_CAST(channelsmod_release),
+ METH_VARARGS | METH_KEYWORDS, channelsmod_release_doc},
+ {"_channel_id", _PyCFunction_CAST(channelsmod__channel_id),
METH_VARARGS | METH_KEYWORDS, NULL},
- {"_register_end_types", _PyCFunction_CAST(channel__register_end_types),
+ {"_register_end_types", _PyCFunction_CAST(channelsmod__register_end_types),
METH_VARARGS | METH_KEYWORDS, NULL},
{NULL, NULL} /* sentinel */
// ChannelID
state->ChannelIDType = add_new_type(
- mod, &ChannelIDType_spec, _channelid_shared, xid_classes);
+ mod, &channelid_typespec, _channelid_shared, xid_classes);
if (state->ChannelIDType == NULL) {
goto error;
}
projects / thirdparty / Python / cpython.git / commitdiff
