portal 3.7.4__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
portal/__init__.py ADDED
@@ -0,0 +1,31 @@
1
+ import multiprocessing as mp
2
+ try:
3
+ mp.set_start_method('spawn')
4
+ except RuntimeError:
5
+ pass
6
+
7
+ from .contextlib import context
8
+ from .contextlib import initfn
9
+ from .contextlib import reset
10
+ from .contextlib import setup
11
+
12
+ from .thread import Thread
13
+ from .process import Process
14
+
15
+ from .server_socket import ServerSocket
16
+ from .client_socket import ClientSocket
17
+ from .client_socket import Disconnected
18
+
19
+ from .client import Client
20
+ from .server import Server
21
+ from .batching import BatchServer
22
+
23
+ from .packlib import pack
24
+ from .packlib import unpack
25
+ from .packlib import tree_equals
26
+
27
+ from .sharray import SharedArray
28
+
29
+ from .utils import free_port
30
+ from .utils import proc_alive
31
+ from .utils import run
portal/batching.py ADDED
@@ -0,0 +1,179 @@
1
+ import threading
2
+
3
+ import numpy as np
4
+ import portal
5
+
6
+ from . import client
7
+ from . import packlib
8
+ from . import process
9
+ from . import server
10
+ from . import server_socket
11
+ from . import sharray
12
+ from . import thread
13
+ from . import utils
14
+
15
+
16
+ class BatchServer:
17
+
18
+ def __init__(
19
+ self, port, name='Server', workers=1, errors=True,
20
+ process=True, shmem=False, **kwargs):
21
+ inner_port = utils.free_port()
22
+ while inner_port == port:
23
+ inner_port = utils.free_port()
24
+ self.name = name
25
+ self.server = server.Server(inner_port, name, workers, errors, **kwargs)
26
+ if process:
27
+ self.running = portal.context.mp.Event()
28
+ else:
29
+ self.running = threading.Event()
30
+ self.process = process
31
+ self.batsizes = {}
32
+ self.batargs = (
33
+ self.running, port, inner_port, f'{name}Batcher',
34
+ self.batsizes, errors, shmem, kwargs)
35
+ self.started = False
36
+
37
+ def bind(self, name, workfn, donefn=None, batch=0, workers=0):
38
+ assert not self.started
39
+ self.batsizes[name] = batch
40
+ self.server.bind(name, workfn, donefn, workers=workers)
41
+
42
+ def start(self, block=True):
43
+ assert not self.started
44
+ self.started = True
45
+ self.running.set()
46
+ if self.process:
47
+ self.batcher = process.Process(
48
+ batcher, *self.batargs, name=f'{self.name}Batcher', start=True)
49
+ else:
50
+ self.batcher = thread.Thread(
51
+ batcher, *self.batargs, name=f'{self.name}Batcher', start=True)
52
+ self.server.start(block=block)
53
+
54
+ def close(self, timeout=None):
55
+ assert self.started
56
+ self.running.clear()
57
+ self.server.close(timeout)
58
+ self.batcher.join(timeout)
59
+ self.batcher.kill()
60
+
61
+ def stats(self):
62
+ return self.server.stats()
63
+
64
+ def __enter__(self):
65
+ self.start(block=False)
66
+ return self
67
+
68
+ def __exit__(self, *e):
69
+ self.close()
70
+
71
+
72
+ def batcher(
73
+ running, outer_port, inner_port, name, batsizes, errors, shmem,
74
+ kwargs):
75
+
76
+ def maybe_recv(outer, inner, jobs, batches):
77
+ if not running.is_set(): # Do not accept further requests.
78
+ return
79
+ try:
80
+ addr, data = outer.recv(timeout=0.0001)
81
+ except TimeoutError:
82
+ return
83
+ reqnum = bytes(data[:8])
84
+ data = data[8:]
85
+ strlen = int.from_bytes(data[:8], 'little', signed=False)
86
+ data = data[8:]
87
+ name, data = bytes(data[:strlen]).decode('utf-8'), data[strlen:]
88
+ if name not in batsizes:
89
+ send_error(addr, reqnum, 3, f'Unknown method {name}')
90
+ return
91
+ data = packlib.unpack(data)
92
+ batch_size = batsizes[name]
93
+ if not batch_size:
94
+ job = inner.call(name, *data)
95
+ job.args = (False, addr, reqnum)
96
+ jobs.append(job)
97
+ return
98
+ leaves, structure = packlib.tree_flatten(data)
99
+ leaves = [np.asarray(x) for x in leaves]
100
+ if any(x.dtype == object for x in leaves):
101
+ send_error(addr, reqnum, 5, 'Only array arguments can be batched.')
102
+ return
103
+ if name not in batches:
104
+ if shmem:
105
+ buffers = [
106
+ sharray.SharedArray((batch_size, *leaf.shape), leaf.dtype)
107
+ for leaf in leaves]
108
+ else:
109
+ buffers = [
110
+ np.empty((batch_size, *leaf.shape), leaf.dtype)
111
+ for leaf in leaves]
112
+ batches[name] = ([], [], structure, buffers)
113
+ addrs, reqnums, reference, buffers = batches[name]
114
+ if structure != reference:
115
+ send_error(addr, reqnum, 6, (
116
+ f'Argument structure {structure} does not match previous ' +
117
+ f'requests with structure {reference} for batched server ' +
118
+ f'method {name}.'))
119
+ return
120
+ index = len(addrs)
121
+ addrs.append(addr)
122
+ reqnums.append(reqnum)
123
+ for buffer, leaf in zip(buffers, leaves):
124
+ buffer[index] = leaf
125
+ if len(addrs) == batch_size:
126
+ del batches[name]
127
+ data = packlib.tree_unflatten(buffers, reference)
128
+ job = inner.call(name, *data)
129
+ job.args = (True, addrs, reqnums)
130
+ jobs.append(job)
131
+
132
+ def maybe_send(outer, inner, jobs):
133
+ done, waiting = [], []
134
+ [done.append(x) if x.done() else waiting.append(x) for x in jobs]
135
+ for job in done:
136
+ batched, addr, reqnum = job.args
137
+ try:
138
+ result = job.result()
139
+ except RuntimeError as e:
140
+ if batched:
141
+ for i, (addr, reqnum) in enumerate(zip(addr, reqnum)):
142
+ send_error(addr, reqnum, 6, e.args[0])
143
+ else:
144
+ send_error(addr, reqnum, 6, e.args[0])
145
+ continue
146
+ status = int(0).to_bytes(8, 'little', signed=True)
147
+ if batched:
148
+ for i, (addr, reqnum) in enumerate(zip(addr, reqnum)):
149
+ data = packlib.pack(packlib.tree_map(lambda x: x[i], result))
150
+ outer.send(addr, reqnum, status, *data)
151
+ else:
152
+ data = packlib.pack(result)
153
+ outer.send(addr, reqnum, status, *data)
154
+ return waiting
155
+
156
+ def send_error(addr, reqnum, status, message):
157
+ assert 1 <= status, status
158
+ status = status.to_bytes(8, 'little', signed=False)
159
+ data = message.encode('utf-8')
160
+ outer.send(addr, reqnum, status, data)
161
+ if errors:
162
+ raise RuntimeError(message)
163
+
164
+ try:
165
+ outer = server_socket.ServerSocket(outer_port, f'{name}Server', **kwargs)
166
+ inner = client.Client(inner_port, f'{name}Client', **kwargs)
167
+ batches = {} # {method: ([addr], [reqnum], structure, [array])}
168
+ jobs = []
169
+ shutdown = False
170
+ while running.is_set() or jobs:
171
+ if running.is_set():
172
+ maybe_recv(outer, inner, jobs, batches)
173
+ elif not shutdown:
174
+ shutdown = True
175
+ outer.shutdown()
176
+ jobs = maybe_send(outer, inner, jobs)
177
+ finally:
178
+ outer.close()
179
+ inner.close()
portal/buffers.py ADDED
@@ -0,0 +1,94 @@
1
+ import collections
2
+ import os
3
+ import weakref
4
+
5
+ import numpy as np
6
+
7
+
8
+ class SendBuffer:
9
+
10
+ def __init__(self, *buffers, maxsize=None):
11
+ for buffer in buffers:
12
+ assert isinstance(buffer, (bytes, bytearray, memoryview)), type(buffer)
13
+ assert not isinstance(buffer, memoryview) or buffer.c_contiguous
14
+ buffers = tuple(
15
+ x.cast('c') if isinstance(x, memoryview) else x for x in buffers)
16
+ length = sum(len(x) for x in buffers)
17
+ assert all(len(x) for x in buffers)
18
+ assert 1 <= length, length
19
+ assert not maxsize or length <= length, (length, maxsize)
20
+ lenbuf = length.to_bytes(8, 'little', signed=False)
21
+ self.buffers = [lenbuf, *buffers]
22
+ self.remaining = collections.deque(self.buffers)
23
+ self.pos = 0
24
+
25
+ def __repr__(self):
26
+ lens = [len(x) for x in self.buffers]
27
+ left = [len(x) for x in self.remaining]
28
+ return f'SendBuffer(pos={self.pos}, lengths={lens} remaining={left})'
29
+
30
+ def reset(self):
31
+ self.remaining = collections.deque(self.buffers)
32
+ self.pos = 0
33
+
34
+ def send(self, sock):
35
+ first, *others = self.remaining
36
+ assert self.pos < len(first)
37
+ # The writev() call blocks but seems to be slightly faster than sendmsg().
38
+ size = os.writev(sock.fileno(), [memoryview(first)[self.pos:], *others])
39
+ # size = sock.sendmsg(
40
+ # [memoryview(first)[self.pos:], *others], (), socket.MSG_DONTWAIT)
41
+ if size == 0:
42
+ raise ConnectionResetError
43
+ assert 0 <= size, size
44
+ self.pos += max(0, size)
45
+ while self.remaining and self.pos >= len(self.remaining[0]):
46
+ self.pos -= len(self.remaining.popleft())
47
+ return size
48
+
49
+ def done(self):
50
+ return not self.remaining
51
+
52
+
53
+ class RecvBuffer:
54
+
55
+ def __init__(self, maxsize):
56
+ self.maxsize = maxsize
57
+ self.lenbuf = b''
58
+ self.buffer = None
59
+ self.pos = 0
60
+
61
+ def __repr__(self):
62
+ length = self.buffer and len(self.buffer)
63
+ return f'RecvBuffer(pos={self.pos}, length={length})'
64
+
65
+ def recv(self, sock):
66
+ if self.buffer is None:
67
+ part = sock.recv(8 - len(self.lenbuf))
68
+ self.lenbuf += part
69
+ size = len(part)
70
+ if len(self.lenbuf) == 8:
71
+ length = int.from_bytes(self.lenbuf, 'little', signed=False)
72
+ assert 1 <= length <= self.maxsize, (1, length, self.maxsize)
73
+ # We use Numpy to allocate uninitialized memory because Python's
74
+ # `bytearray(length)` zero initializes which is slow. This also means
75
+ # the buffer cannot be pickled accidentally unless explicitly converted
76
+ # to a `bytes()` object, which is a nice bonus for preventing
77
+ # performance bugs in user code.
78
+ arr = np.empty(length, np.uint8)
79
+ self.buffer = memoryview(arr.data)
80
+ weakref.finalize(self.buffer, lambda arr=arr: arr)
81
+ self.pos = 0
82
+ else:
83
+ size = sock.recv_into(self.buffer[self.pos:])
84
+ self.pos += max(0, size)
85
+ assert 0 <= self.pos <= len(self.buffer), (0, self.pos, len(self.buffer))
86
+ if size == 0:
87
+ raise ConnectionResetError
88
+ return size
89
+
90
+ def done(self):
91
+ return self.buffer and self.pos == len(self.buffer)
92
+
93
+ def result(self):
94
+ return self.buffer
portal/client.py ADDED
@@ -0,0 +1,190 @@
1
+ import collections
2
+ import functools
3
+ import itertools
4
+ import threading
5
+ import time
6
+ import weakref
7
+
8
+ from . import client_socket
9
+ from . import packlib
10
+
11
+
12
+ class Client:
13
+
14
+ def __init__(self, addr, name='Client', maxinflight=16, **kwargs):
15
+ assert 1 <= maxinflight, maxinflight
16
+ self.maxinflight = maxinflight
17
+ self.reqnum = iter(itertools.count(0))
18
+ self.futures = {}
19
+ self.errors = collections.deque()
20
+ self.sendrate = [0, time.time()]
21
+ self.recvrate = [0, time.time()]
22
+ self.waitmean = [0, 0]
23
+ self.cond = threading.Condition()
24
+ self.lock = threading.Lock()
25
+ # Socket is created after the above attributes because the callbacks access
26
+ # some of the attributes.
27
+ self.socket = client_socket.ClientSocket(addr, name, start=False, **kwargs)
28
+ self.socket.callbacks_recv.append(self._recv)
29
+ self.socket.callbacks_disc.append(self._disc)
30
+ self.socket.callbacks_conn.append(self._conn)
31
+ self.socket.start()
32
+
33
+ @property
34
+ def connected(self):
35
+ return self.socket.connected
36
+
37
+ def __getattr__(self, name):
38
+ if name.startswith('_'):
39
+ raise AttributeError(name)
40
+ try:
41
+ return functools.partial(self.call, name)
42
+ except AttributeError:
43
+ raise ValueError(name)
44
+
45
+ def stats(self):
46
+ now = time.time()
47
+ stats = {
48
+ 'inflight': len(self.futures),
49
+ 'numsend': self.sendrate[0],
50
+ 'numrecv': self.recvrate[0],
51
+ 'sendrate': self.sendrate[0] / (now - self.sendrate[1]),
52
+ 'recvrate': self.recvrate[0] / (now - self.recvrate[1]),
53
+ 'waitmean': self.waitmean[0] and (self.waitmean[1] / self.waitmean[0]),
54
+ }
55
+ self.sendrate = [0, now]
56
+ self.recvrate = [0, now]
57
+ self.waitmean = [0, 0]
58
+ return stats
59
+
60
+ def connect(self, timeout=None):
61
+ return self.socket.connect(timeout)
62
+
63
+ def call(self, method, *data):
64
+ reqnum = next(self.reqnum).to_bytes(8, 'little', signed=False)
65
+ start = time.time()
66
+ while len(self.futures) >= self.maxinflight:
67
+ with self.cond: self.cond.wait(timeout=0.2)
68
+ try:
69
+ self.socket.require_connection(timeout=0)
70
+ except TimeoutError:
71
+ pass
72
+ with self.lock:
73
+ self.waitmean[1] += time.time() - start
74
+ self.waitmean[0] += 1
75
+ self.sendrate[0] += 1
76
+ if self.errors: # Raise errors of dropped futures.
77
+ raise self.errors.popleft()
78
+ name = method.encode('utf-8')
79
+ strlen = len(name).to_bytes(8, 'little', signed=False)
80
+ sendargs = (reqnum, strlen, name, *packlib.pack(data))
81
+ rai = [False]
82
+ future = Future(rai)
83
+ future.sendargs = sendargs
84
+ self.futures[reqnum] = future
85
+ # Store future before sending request because the response may come fast
86
+ # and the response handler runs in the socket's background thread.
87
+ try:
88
+ self.socket.send(*sendargs)
89
+ except client_socket.Disconnected:
90
+ future = self.futures.pop(reqnum)
91
+ future.rai[0] = True
92
+ raise
93
+ return future
94
+
95
+ def close(self, timeout=None):
96
+ for future in self.futures.values():
97
+ self._seterr(future, client_socket.Disconnected)
98
+ self.futures.clear()
99
+ self.socket.close(timeout)
100
+
101
+ def _recv(self, data):
102
+ assert len(data) >= 16, 'Unexpectedly short response'
103
+ reqnum = bytes(data[:8])
104
+ status = int.from_bytes(data[8:16], 'little', signed=False)
105
+ future = self.futures.pop(reqnum, None)
106
+ if not future:
107
+ existing = sorted(self.futures.keys())
108
+ print(f'Unexpected request number: {reqnum}', existing)
109
+ elif status == 0:
110
+ data = packlib.unpack(data[16:])
111
+ future.set_result(data)
112
+ with self.cond: self.cond.notify_all()
113
+ else:
114
+ message = bytes(data[16:]).decode('utf-8')
115
+ self._seterr(future, RuntimeError(message))
116
+ with self.cond: self.cond.notify_all()
117
+ try:
118
+ self.socket.recv()
119
+ except AssertionError:
120
+ pass # Socket is already closed.
121
+
122
+ def _disc(self):
123
+ if self.socket.options.autoconn:
124
+ for future in list(self.futures.values()):
125
+ future.resend = True
126
+ else:
127
+ for future in list(self.futures.values()):
128
+ self._seterr(future, client_socket.Disconnected)
129
+ self.futures.clear()
130
+
131
+ def _conn(self):
132
+ if self.socket.options.autoconn:
133
+ for future in list(self.futures.values()):
134
+ if getattr(future, 'resend', False):
135
+ self.socket.send(*future.sendargs)
136
+
137
+ def _seterr(self, future, e):
138
+ future.set_error(e)
139
+ rai = future.rai
140
+ weakref.finalize(future, lambda: (
141
+ None if rai[0] else self.errors.append(e)))
142
+
143
+
144
+ class Future:
145
+
146
+ def __init__(self, rai):
147
+ assert rai == [False]
148
+ self.rai = rai
149
+ self.con = threading.Condition()
150
+ self.don = False
151
+ self.res = None
152
+ self.err = None
153
+
154
+ def __repr__(self):
155
+ if not self.done:
156
+ return 'Future(done=False)'
157
+ elif self.err:
158
+ return f"Future(done=True, error='{self.err}', raised={self.rai[0]})"
159
+ else:
160
+ return 'Future(done=True)'
161
+
162
+ def wait(self, timeout=None):
163
+ if self.don:
164
+ return self.don
165
+ with self.con: return self.con.wait(timeout)
166
+
167
+ def done(self):
168
+ return self.don
169
+
170
+ def result(self, timeout=None):
171
+ if not self.wait(timeout):
172
+ raise TimeoutError
173
+ assert self.don
174
+ if self.err is None:
175
+ return self.res
176
+ if not self.rai[0]:
177
+ self.rai[0] = True
178
+ raise self.err
179
+
180
+ def set_result(self, result):
181
+ assert not self.don
182
+ self.don = True
183
+ self.res = result
184
+ with self.con: self.con.notify_all()
185
+
186
+ def set_error(self, e):
187
+ assert not self.don
188
+ self.don = True
189
+ self.err = e
190
+ with self.con: self.con.notify_all()