Datasets:
File size: 2,876 Bytes
faa3682 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 |
import threading
import time
import portal
CLIENT = None
REPLICA = None
def setup(is_server, replica, replicas, port, addr):
global CLIENT, REPLICA
assert CLIENT is None
if replicas <= 1:
return
print('CLOCK PORT:', port)
print('CLOCK ADDR:', addr)
if is_server:
_start_server(port, replicas)
client = portal.Client(addr, 'ClockClient')
client.connect()
CLIENT = client
REPLICA = replica
def _start_server(port, replicas):
clocks = []
requests = []
result = [None]
receive = threading.Barrier(replicas)
respond = threading.Barrier(replicas)
def create(replica, every):
requests.append(every)
receive.wait()
if replica == 0:
assert len(requests) == replicas, (len(requests), replicas)
assert all(x == every for x in requests)
clockid = len(clocks)
clocks.append([float(every), time.time()])
result[0] = clockid
requests.clear()
respond.wait()
return result[0]
def should(replica, clockid, skip):
requests.append((clockid, skip))
receive.wait()
if replica == 0:
assert len(requests) == replicas, (len(requests), replicas)
clockids, skips = zip(*requests)
assert all(x == clockid for x in clockids)
every, prev = clocks[clockid]
now = time.time()
if every == 0:
decision = False
elif every < 0:
decision = True
elif now >= prev + every:
clocks[clockid][1] = now
decision = True
else:
decision = False
decision = decision and not any(skips)
result[0] = decision
requests.clear()
respond.wait()
return result[0]
server = portal.Server(port, 'ClockServer')
server.bind('create', create, workers=replicas)
server.bind('should', should, workers=replicas)
server.start(block=False)
class GlobalClock:
def __init__(self, every, first=False):
self.multihost = bool(CLIENT)
if self.multihost:
self.clockid = CLIENT.create(REPLICA, every).result()
self.skip_next = (not first)
else:
self.clock = LocalClock(every, first)
def __call__(self, step=None, skip=None):
if self.multihost:
if self.skip_next:
self.skip_next = False
skip = True
return CLIENT.should(REPLICA, self.clockid, bool(skip)).result()
else:
return self.clock(step, skip)
class LocalClock:
def __init__(self, every, first=False):
self.every = every
self.prev = None
self.first = first
def __call__(self, step=None, skip=None):
if skip:
return False
if self.every == 0: # Zero means off
return False
if self.every < 0: # Negative means always
return True
now = time.time()
if self.prev is None:
self.prev = now
return self.first
if now >= self.prev + self.every:
self.prev = now
return True
return False
|