def handle_ticktock_to_next_update(force): t = res_manager.get_next_update_time() if t < 0: return False else: if force: while Clock.get() < t: Clock.tick() return handle_ticktock(1) else: return handle_ticktock(t - Clock.get())
def run_timer(): clk = Clock.get() if clk not in timers: return callback_list = timers[clk] for callback in callback_list: callback()
def update(name, cycle=None, param=None): changed_res_set.add(name) res = get_res(name) res.update(param) if cycle is not None: add_timer_callback(Clock.get() + cycle(), lambda: update(name, cycle, param))
class Main(object): def __init__(self): logger.info('Starting Bart service') self.clock = Clock() self.bart = Bart() self.display = Display() signal.signal(signal.SIGINT, self.signal_handler) signal.signal(signal.SIGTERM, self.signal_handler) def signal_handler(self, signal, frame): logger.info('Caught signal {}. Shutting down.'.format(signal)) self.clock.stop() self.bart.stop() self.display.stop() sys.exit(0) def run(self): show_clock = False while True: if show_clock: self.display.display(self.clock.get(), True) else: self.display.display(self.bart.get(), False) show_clock = not show_clock time.sleep(1)
def get_next_update_time(): while len(timers) > 0: t = min(timers) if t < Clock.get(): timers.pop(t, None) else: return t return -1
def report_xml(file_name="report.xml", clock=-1): cur = Clock.get() if clock < 0: clock += cur content = E.content(clock=str(clock)) for name in pool: value = str(pool.get(name).get_value(clock)) content.insert(0, E.feature(E.name(name), E.currentValue(value))) with open(file_name, "w") as fout: fout.write(tostring(content, encoding='utf-8', xml_declaration=True, pretty_print=True))
def get_value(self, clock=-1): cur = Clock.get() if clock < 0: clock = cur + clock if clock > cur or clock < 0: return None for item in reversed(self.value): if item[0] <= clock: return item[1]
def get_value(value, v): if utils.is_callable(value): return value() elif value == "$self": return v elif value == "$clock": return Clock.get() elif utils.is_string(value) and value.startswith("$"): return res_manager.get(value[1:]) else: return value
def get_value_history(self): values = self.value clk = Clock.get() ret = [None] * clk if values is None or len(values) == 0: return idx = 0 pre_value = None for time, value in values: while idx < time: ret[idx] = pre_value idx += 1 pre_value = value if time < clk: ret[time] = value while idx < clk: ret[idx] = pre_value idx += 1 return ret
def report(): print "-----------------------------------------------------" print "CLOCK:", Clock.get() res_manager.report() print "+++++++++++++++++++++++++++++++++++++++++++++++++++++"
def update_delay(name, delay, cycle, param=None): add_timer_callback(Clock.get() + delay, lambda: update(name, cycle, param))
def set_value(self, value): clk = Clock.get() #if len(self.value) > 1 and self.value[-1][0] == clk: self.value.append((clk, value))
def handle_ticktock(time): ts = int(time * 2) for i in range(ts): tick_or_tock() return Clock.get()
class LamportNode: def __init__(self, nodes, index): self.clock = Clock() self.index = index self.nodes = {i: n for i, n in nodes.items()} try: self.host = nodes[index]["host"] self.port = int(nodes[index]["port"]) self.chance = float(nodes[index]["chance"]) except KeyError: raise InvalidNodeError(f"Invalid node {index}") # Removes own node from the list to avoid sending messages to itself self.nodes.pop(self.index, None) self.running = False self.logger = setup_logger(self.index) def start(self): self.running = True conn_listener = Listener(self.index, self.port, self.clock) conn_listener.start() for i in range(constants.EVENTS_COUNT): if not self.running: break sleep(min(random.random() + 0.5, 1)) self.clock.increment() if random.random() > self.chance: # local self.logger.info(f"{perf_counter_ns() // 1000} {self.index} {self.clock.get()}{self.index} l") else: # remote idx, node = self.get_node() try: self.send_message(idx, node) except SocketTimeout: print( f"""Error: Timeout sending message to node {idx} ({node["host"]}:{node["port"]})""" ) break conn_listener.stop() def send_message(self, index, node): node_addr = (node["host"], node["port"]) clock = self.clock.get() sock = create_socket() callback_port = bind_random_port(sock) sock.sendto( f"{self.index} {clock} {self.host} {callback_port}".encode("utf-8"), node_addr, ) wait_response(sock, node_addr, 3.0) sock.close() self.logger.info(f"""{perf_counter_ns() // 1000} {self.index} {clock}{self.index} s {index}""") def get_node(self): index = random.choice(list(self.nodes.keys())) return index, self.nodes[index] def stop(self): self.running = False
def get(data, return_type=None): if type(data) is not dict or "method" not in data: if return_type is None: return data elif return_type == "lambda": return lambda: data else: return None method = data["method"] parameter = data["parameter"] if method.startswith(MATH_PREFIX): if method == METHOD_MATH_ADD: a = get(parameter["a"]) b = get(parameter["b"]) method = lambda value: get_value(a, value) + get_value(b, value) elif method == METHOD_MATH_DIVISION: a = get(parameter["a"]) b = get(parameter["b"]) method = lambda value: get_value(a, value) / get_value(b, value) elif method == METHOD_MATH_MINUS: a = get(parameter["a"]) b = get(parameter["b"]) method = lambda value: get_value(a, value) - get_value(b, value) elif method == METHOD_MATH_MULTIPLY: a = get(parameter["a"]) b = get(parameter["b"]) method = lambda value: get_value(a, value) * get_value(b, value) elif method == METHOD_MATH_MOD: a = get(parameter["a"]) b = get(parameter["b"]) method = lambda value: get_value(a, value) % get_value(b, value) elif method == METHOD_MATH_LINEAR: a = get(parameter["a"]) b = get(parameter["b"]) x = get(parameter["x"]) method = lambda value: get_value(a, value) * get_value(x, value) + get_value(b, value) elif method == METHOD_MATH_SIN: a = get(parameter["a"]) b = get(parameter["b"]) x = get(parameter["x"]) method = lambda value: get_value(a, value) * math.sin(get_value(x, value)) + get_value(b, value) elif method == METHOD_MATH_LOG: a = get(parameter["a"]) b = get(parameter["b"]) x = get(parameter["x"]) method = lambda value: get_value(a, value) * math.log(get_value(x, value)) + get_value(b, value) elif method == METHOD_MATH_MEAN: terms = parameter["term"] method = lambda value: 1.0 * sum([get_value(term, value) for term in terms]) / len(terms) elif method == METHOD_MATH_SUM: terms = parameter["term"] #print terms method = lambda value: sum([get_value(term, value) for term in terms]) else: print "not support method:", method elif method.startswith(PROBABILITY_PREFIX): if method == METHOD_PROBABILITY_MARKOV_CHAIN: state_set = parameter["state_set"] init_state = parameter["init_state"] trans_matrix = parameter["trans_matrix"] method = lambda value: markov_chain(value, state_set, init_state, trans_matrix) elif method == METHOD_PROBABILITY_NORMAL_VARIATE_RAND: mu = get(parameter["mu"]) sigma = get(parameter["sigma"]) method = lambda value: normalvariate(get_value(mu, value), get_value(sigma, value)) elif method == METHOD_PROBABILITY_SIMPLE_RAND: min_value = get(parameter["min"]) max_value = get(parameter["max"]) method = lambda value: randint(get_value(min_value, value), get_value(max_value, value)) else: print "not support method:", method else: if method == METHOD_OTHERS_COMBINE: sections = parameter["section"] # print "sections:", sections method = lambda value: dict((section, get_value(section, value)) for section in sections) elif method == METHOD_OTHERS_DATA_LIST: data_list = parameter["data_list"] method = lambda value: data_list[Clock.get() % len(data_list)] else: print "not support method:", method return method