def test_Rule_is_valid(): class FakeRuleManager(): def __init__(self): pass def get_memory_manager(self): return 0.5 def fake_condition(val1, val2): return val1 < 0.5 rule = Rule(1, None, fake_condition) rule.set_rule_manager(FakeRuleManager()) for _ in range(100): val1 = random.random() assert rule.is_valid(val1) == (val1 < 0.5)
def __init__(self, name, memories=[]): self.name = name self.other_is_setted = False self.is_started = False self.rule = Rule(None, None, None) self.rule.protocols.append(self) self.memories = memories self.own = None
def test_RuleManager_expire(): ruleset = RuleManager() rule = Rule(1, None, None) rule.protocols.append("protocol") assert ruleset.load(rule) and len(ruleset) == 1 protocol = ruleset.expire(rule) assert len(ruleset) == 0 assert protocol == ["protocol"]
def test_RuleManager_load(): rule_manager = RuleManager() for _ in range(100): priority = random.randint(20) rule = Rule(priority, None, None) rule_manager.load(rule) for i in range(1, len(rule_manager)): assert rule_manager[i].priority >= rule_manager[i - 1].priority assert id(rule_manager[i].rule_manager) == id(rule_manager)
def test_expire(): tl = Timeline() node = FakeNode("node", tl) tl.init() for info in node.resource_manager.memory_manager: info.to_occupied() rule = Rule(0, None, None) for i in range(6): node.memory_array[i].detach(node.memory_array) p1 = FakeProtocol("waiting_protocol", [node.memory_array[0]]) node.memory_array[0].attach(p1) p2 = FakeProtocol("pending_protocol", [node.memory_array[1]]) node.memory_array[1].attach(p2) p3 = FakeProtocol("running_protocol", [node.memory_array[2]]) node.memory_array[2].attach(p3) p4 = FakeProtocol("other_waiting_protocol", [node.memory_array[3]]) node.memory_array[3].attach(p4) p5 = FakeProtocol("other_pending_protocol", [node.memory_array[4]]) node.memory_array[4].attach(p5) p6 = FakeProtocol("other_running_protocol", [node.memory_array[5]]) node.memory_array[5].attach(p6) for p in [p1, p2, p3]: p.rule = rule rule.protocols.append(p) node.resource_manager.rule_manager.load(rule) for p in [p3, p6]: node.protocols.append(p) for p in [p2, p5]: node.resource_manager.pending_protocols.append(p) for p in [p1, p4]: node.resource_manager.waiting_protocols.append(p) for i in range(6): assert node.resource_manager.memory_manager[i].state == "OCCUPIED" node.resource_manager.expire(rule) assert p1 not in node.resource_manager.waiting_protocols and p4 in node.resource_manager.waiting_protocols assert p2 not in node.resource_manager.pending_protocols assert p5 in node.resource_manager.pending_protocols assert p3 not in node.protocols and p6 in node.protocols for i in range(3): assert node.resource_manager.memory_manager[i].state == "RAW" for i in range(3, 6): assert node.resource_manager.memory_manager[i].state == "OCCUPIED" for i, memory in enumerate(node.memory_array): if i < 3: assert len(memory._observers) == 1 and isinstance( memory._observers.pop(), MemoryArray) elif i < 6: assert len(memory._observers) == 1 and isinstance( memory._observers.pop(), FakeProtocol)
def test_Rule_do(): class FakeRuleManager(RuleManager): def __init__(self): RuleManager.__init__(self) self.log = [] def send_request(self, protocol, req_dst, req_condition): self.log.append((protocol.name, req_dst, req_condition)) class FakeProtocol(): def __init__(self, name): self.name = name self.rule = None self.memories = [] def fake_action(memories_info): if len(memories_info) == 1: return FakeProtocol("protocol1"), ["req_dst1"], ["req_condition1"] else: return FakeProtocol("protocol2"), [None], [None] tl = Timeline() rule_manager = FakeRuleManager() rule = Rule(1, fake_action, None) rule.set_rule_manager(rule_manager) assert rule.priority == 1 and len(rule.protocols) == 0 memory = Memory("mem", tl, fidelity=1, frequency=0, efficiency=1, coherence_time=-1, wavelength=500) memories_info = [MemoryInfo(memory, 0)] assert len(memory._observers) == 0 rule.do(memories_info) assert len(rule.protocols) == 1 and rule.protocols[0].name == "protocol1" assert len(rule_manager.log) == 1 and rule_manager.log[0] == ("protocol1", "req_dst1", "req_condition1") assert rule.protocols[0].rule == rule assert len(memory._observers) == 1 mem1 = Memory("1", tl, fidelity=1, frequency=0, efficiency=1, coherence_time=-1, wavelength=500) mem2 = Memory("2", tl, fidelity=1, frequency=0, efficiency=1, coherence_time=-1, wavelength=500) memories_info = [MemoryInfo(mem1, 0), MemoryInfo(mem2, 1)] rule.do(memories_info) assert len(rule.protocols) == 2 and rule.protocols[1].name == "protocol2" assert len(rule_manager.log) == 2 and rule_manager.log[1] == ("protocol2", None, None) assert rule.protocols[1].rule == rule assert len(mem1._observers) == len(mem2._observers) == 1
def test_update(): def fake_condition(memo_info, manager): if memo_info.state == "ENTANGLED" and memo_info.fidelity > 0.8: return [memo_info] else: return [] def fake_action(memories): return FakeProtocol("protocol"), [None], [None] tl = Timeline() node = FakeNode("node", tl) assert len(node.resource_manager.rule_manager) == 0 rule = Rule(1, fake_action, fake_condition) node.resource_manager.load(rule) assert len(node.resource_manager.rule_manager) == 1 for memo_info in node.resource_manager.memory_manager: assert memo_info.state == "RAW" protocol = FakeProtocol("protocol1") node.protocols.append(protocol) node.memory_array[0].fidelity = 0.5 node.memory_array[0].detach(node.memory_array) node.memory_array[0].attach(protocol) node.resource_manager.update(protocol, node.memory_array[0], "ENTANGLED") assert len(node.protocols) == len(rule.protocols) == 0 assert len(node.memory_array[0]._observers) == 1 assert node.resource_manager.memory_manager[0].state == "ENTANGLED" protocol = FakeProtocol("protocol2") node.protocols.append(protocol) node.memory_array[1].fidelity = 0.9 node.memory_array[1].attach(protocol) node.resource_manager.update(protocol, node.memory_array[1], "ENTANGLED") assert len(node.resource_manager.waiting_protocols) == len( rule.protocols) == 1 assert len(node.memory_array[1]._observers) == 2 assert node.resource_manager.memory_manager[1].state == "OCCUPIED"
def test_load(): def fake_condition(memo_info, manager): if memo_info.state == "RAW": return [memo_info] else: return [] def fake_action(memories): return FakeProtocol("protocol"), [None], [None] tl = Timeline() node = FakeNode("node", tl) assert len(node.resource_manager.rule_manager) == 0 rule = Rule(1, fake_action, fake_condition) for memo_info in node.resource_manager.memory_manager: assert memo_info.state == "RAW" node.resource_manager.load(rule) assert len(node.resource_manager.rule_manager) == 1 for memo_info in node.resource_manager.memory_manager: assert memo_info.state == "OCCUPIED" assert len(node.resource_manager.waiting_protocols) == len( node.memory_array) assert len(node.resource_manager.pending_protocols) == 0 assert len(rule.protocols) == len(node.memory_array)
def test_ResourceManager2(): from sequence.kernel.process import Process from sequence.kernel.event import Event from sequence.components.optical_channel import ClassicalChannel, QuantumChannel from sequence.topology.node import BSMNode from sequence.entanglement_management.generation import EntanglementGenerationA class TestNode(Node): def __init__(self, name, tl): Node.__init__(self, name, tl) self.memory_array = MemoryArray(name + ".MemoryArray", tl, num_memories=50) self.memory_array.owner = self self.resource_manager = ResourceManager(self) def receive_message(self, src: str, msg: "Message") -> None: if msg.receiver == "resource_manager": self.resource_manager.received_message(src, msg) else: if msg.receiver is None: matching = [ p for p in self.protocols if type(p) == msg.protocol_type ] for p in matching: p.received_message(src, msg) else: for protocol in self.protocols: if protocol.name == msg.receiver: protocol.received_message(src, msg) break def get_idle_memory(self, info): pass def eg_rule_condition(memory_info, manager): if memory_info.state == "RAW": return [memory_info] else: return [] def eg_rule_action1(memories_info): def eg_req_func(protocols): for protocol in protocols: if isinstance(protocol, EntanglementGenerationA): return protocol memories = [info.memory for info in memories_info] memory = memories[0] protocol = EntanglementGenerationA(None, "EGA." + memory.name, "mid_node", "node2", memory) protocol.primary = True return [protocol, ["node2"], [eg_req_func]] def eg_rule_action2(memories_info): memories = [info.memory for info in memories_info] memory = memories[0] protocol = EntanglementGenerationA(None, "EGA." + memory.name, "mid_node", "node1", memory) return [protocol, [None], [None]] tl = Timeline() node1, node2 = TestNode("node1", tl), TestNode("node2", tl) mid_node = BSMNode("mid_node", tl, [node1.name, node2.name]) mid_node.bsm.detectors[0].efficiency = 1 mid_node.bsm.detectors[1].efficiency = 1 cc0 = ClassicalChannel("cc_n1_n2", tl, 0, 1e3) cc1 = ClassicalChannel("cc_n2_n1", tl, 0, 1e3) cc2 = ClassicalChannel("cc_n1_m", tl, 0, 1e3) cc3 = ClassicalChannel("cc_m_n1", tl, 0, 1e3) cc4 = ClassicalChannel("cc_n2_m", tl, 0, 1e3) cc5 = ClassicalChannel("cc_m_n2", tl, 0, 1e3) cc0.set_ends(node1, node2) cc1.set_ends(node2, node1) cc2.set_ends(node1, mid_node) cc3.set_ends(mid_node, node1) cc4.set_ends(node2, mid_node) cc5.set_ends(mid_node, node2) qc0 = QuantumChannel("qc_n1_m", tl, 0, 1e3, frequency=8e7) qc1 = QuantumChannel("qc_n2_m", tl, 0, 1e3, frequency=8e7) qc0.set_ends(node1, mid_node) qc1.set_ends(node2, mid_node) tl.init() rule1 = Rule(10, eg_rule_action1, eg_rule_condition) node1.resource_manager.load(rule1) rule2 = Rule(10, eg_rule_action2, eg_rule_condition) node2.resource_manager.load(rule2) process = Process(node1.resource_manager, "expire", [rule1]) event = Event(10, process) tl.schedule(event) process = Process(node2.resource_manager, "expire", [rule2]) event = Event(10, process) tl.schedule(event) tl.run() # for info in node1.resource_manager.memory_manager: # print(info.memory.name, info.state, info.remote_memo) # # for info in node2.resource_manager.memory_manager: # print(info.memory.name, info.state, info.remote_memo) for info in node1.resource_manager.memory_manager: assert info.state == "RAW" for info in node2.resource_manager.memory_manager: assert info.state == "RAW" assert len(node1.protocols) == len(node2.protocols) == 0 assert len(node1.resource_manager.pending_protocols) == len( node2.resource_manager.pending_protocols) == 0 assert len(node1.resource_manager.waiting_protocols) == len( node2.resource_manager.waiting_protocols) == 0
def add_eg_rules(index: int, path: List[RouterNode], middles: List[BSMNode]): assert len(path) == len(middles) + 1 node_names = [node.name for node in path] middle_names = [node.name for node in middles] node_mems = [[10, 20], [10, 30], [0, 10]] node = path[index] mem_range = node_mems[index] if index > 0: def eg_rule_condition(memory_info: "MemoryInfo", manager: "MemoryManager"): if memory_info.state == "RAW" and memory_info.index in range( mem_range[0], mem_range[1])[:10]: return [memory_info] else: return [] def eg_rule_action(memories_info: List["MemoryInfo"]): memories = [info.memory for info in memories_info] memory = memories[0] protocol = EntanglementGenerationA(None, "EGA." + memory.name, middle_names[index - 1], node_names[index - 1], memory) return [protocol, [None], [None]] rule = Rule(10, eg_rule_action, eg_rule_condition) node.resource_manager.load(rule) if index < (len(path) - 1): if index == 0: def eg_rule_condition(memory_info: "MemoryInfo", manager: "MemoryManager"): if memory_info.state == "RAW" and memory_info.index in range( mem_range[0], mem_range[1]): return [memory_info] else: return [] else: def eg_rule_condition(memory_info: "MemoryInfo", manager: "MemoryManager"): if memory_info.state == "RAW" and memory_info.index in range( mem_range[0], mem_range[1])[10:]: return [memory_info] else: return [] def eg_rule_action(memories_info: List["MemoryInfo"]): def req_func(protocols): for protocol in protocols: if isinstance(protocol, EntanglementGenerationA ) and protocol.other == node.name and path[ index + 1].memory_array.memories.index( protocol.memory) in range( node_mems[index + 1][0], node_mems[index + 1][1]): return protocol memories = [info.memory for info in memories_info] memory = memories[0] protocol = EntanglementGenerationA(None, "EGA." + memory.name, middle_names[index], node_names[index + 1], memory) return [protocol, [node_names[index + 1]], [req_func]] rule = Rule(10, eg_rule_action, eg_rule_condition) node.resource_manager.load(rule)
def add_es_rules(index: int, path: List[RouterNode], target_fidelity: float, succ_prob: float, degradation: float): node_names = [node.name for node in path] node_mems = [[10, 20], [10, 30], [0, 10]] node = path[index] mem_range = node_mems[index] def es_rule_actionB(memories_info: List["MemoryInfo"]): memories = [info.memory for info in memories_info] memory = memories[0] protocol = EntanglementSwappingB(None, "ESB." + memory.name, memory) return [protocol, [None], [None]] if index == 0: def es_rule_condition(memory_info: "MemoryInfo", manager: "MemoryManager"): if (memory_info.state == "ENTANGLED" and memory_info.index in range(mem_range[0], mem_range[1]) and memory_info.remote_node != node_names[-1] and memory_info.fidelity >= target_fidelity): return [memory_info] else: return [] rule = Rule(10, es_rule_actionB, es_rule_condition) node.resource_manager.load(rule) elif index == len(path) - 1: def es_rule_condition(memory_info: "MemoryInfo", manager: "MemoryManager"): if (memory_info.state == "ENTANGLED" and memory_info.index in range(mem_range[0], mem_range[1]) and memory_info.remote_node != node_names[0] and memory_info.fidelity >= target_fidelity): return [memory_info] else: return [] rule = Rule(10, es_rule_actionB, es_rule_condition) node.resource_manager.load(rule) else: _path = node_names[:] while _path.index(node.name) % 2 == 0: new_path = [] for i, n in enumerate(_path): if i % 2 == 0 or i == len(path) - 1: new_path.append(n) _path = new_path _index = _path.index(node.name) left, right = _path[_index - 1], _path[_index + 1] def es_rule_conditionA(memory_info: "MemoryInfo", manager: "MemoryManager"): if (memory_info.state == "ENTANGLED" and memory_info.index in range(mem_range[0], mem_range[1]) and memory_info.remote_node == left and memory_info.fidelity >= target_fidelity): for info in manager: if (info.state == "ENTANGLED" and info.index in range(mem_range[0], mem_range[1]) and info.remote_node == right and info.fidelity >= target_fidelity): return [memory_info, info] elif (memory_info.state == "ENTANGLED" and memory_info.index in range(mem_range[0], mem_range[1]) and memory_info.remote_node == right and memory_info.fidelity >= target_fidelity): for info in manager: if (info.state == "ENTANGLED" and info.index in range(mem_range[0], mem_range[1]) and info.remote_node == left and info.fidelity >= target_fidelity): return [memory_info, info] return [] def es_rule_actionA(memories_info: List["MemoryInfo"]): memories = [info.memory for info in memories_info] def req_func1(protocols): for protocol in protocols: if (isinstance(protocol, EntanglementSwappingB) and protocol.memory.name == memories_info[0].remote_memo): return protocol def req_func2(protocols): for protocol in protocols: if (isinstance(protocol, EntanglementSwappingB) and protocol.memory.name == memories_info[1].remote_memo): return protocol protocol = EntanglementSwappingA( None, "ESA.%s.%s" % (memories[0].name, memories[1].name), memories[0], memories[1], success_prob=succ_prob, degradation=degradation) dsts = [info.remote_node for info in memories_info] req_funcs = [req_func1, req_func2] return [protocol, dsts, req_funcs] rule = Rule(10, es_rule_actionA, es_rule_conditionA) node.resource_manager.load(rule) def es_rule_conditionB(memory_info: "MemoryInfo", manager: "MemoryManager") -> List["MemoryInfo"]: if (memory_info.state == "ENTANGLED" and memory_info.index in range(mem_range[0], mem_range[1]) and memory_info.remote_node not in [left, right] and memory_info.fidelity >= target_fidelity): return [memory_info] else: return [] rule = Rule(10, es_rule_actionB, es_rule_conditionB) node.resource_manager.load(rule)
def add_ep_rules(index: int, path: List[RouterNode], target_fidelity: float): node_names = [node.name for node in path] node_mems = [[10, 20], [10, 30], [0, 10]] node = path[index] mem_range = node_mems[index] if index > 0: def ep_rule_condition(memory_info: "MemoryInfo", manager: "MemoryManager"): if (memory_info.index in range(mem_range[0], mem_range[1]) and memory_info.state == "ENTANGLED" and memory_info.fidelity < target_fidelity): for info in manager: if (info != memory_info and info.index in range( mem_range[0], mem_range[1])[:10] and info.state == "ENTANGLED" and info.remote_node == memory_info.remote_node and info.fidelity == memory_info.fidelity): assert memory_info.remote_memo != info.remote_memo return [memory_info, info] return [] def ep_rule_action(memories_info: List["MemoryInfo"]): memories = [info.memory for info in memories_info] def req_func(protocols): _protocols = [] for protocol in protocols: if not isinstance(protocol, BBPSSW): continue if protocol.kept_memo.name == memories_info[0].remote_memo: _protocols.insert(0, protocol) if protocol.kept_memo.name == memories_info[1].remote_memo: _protocols.insert(1, protocol) if len(_protocols) != 2: return None protocols.remove(_protocols[1]) _protocols[1].rule.protocols.remove(_protocols[1]) _protocols[1].kept_memo.detach(_protocols[1]) _protocols[0].meas_memo = _protocols[1].kept_memo _protocols[0].memories = [ _protocols[0].kept_memo, _protocols[0].meas_memo ] _protocols[0].name = _protocols[0].name + "." + _protocols[ 0].meas_memo.name _protocols[0].meas_memo.attach(_protocols[0]) _protocols[0].t0 = _protocols[0].kept_memo.timeline.now() return _protocols[0] name = "EP.%s.%s" % (memories[0].name, memories[1].name) protocol = BBPSSW(None, name, memories[0], memories[1]) dsts = [memories_info[0].remote_node] req_funcs = [req_func] return [protocol, dsts, req_funcs] rule = Rule(10, ep_rule_action, ep_rule_condition) node.resource_manager.load(rule) if index < len(path) - 1: if index == 0: def ep_rule_condition(memory_info: "MemoryInfo", manager: "MemoryManager"): if (memory_info.index in range(mem_range[0], mem_range[1]) and memory_info.state == "ENTANGLED" and memory_info.fidelity < target_fidelity): return [memory_info] return [] else: def ep_rule_condition(memory_info: "MemoryInfo", manager: "MemoryManager"): if (memory_info.index in range(mem_range[0], mem_range[1])[10:] and memory_info.state == "ENTANGLED" and memory_info.fidelity < target_fidelity): return [memory_info] return [] def ep_rule_action(memories_info: List["MemoryInfo"]): memories = [info.memory for info in memories_info] name = "EP.%s" % (memories[0].name) protocol = BBPSSW(None, name, memories[0], None) return protocol, [None], [None] rule = Rule(10, ep_rule_action, ep_rule_condition) node.resource_manager.load(rule)
qc_atten = 0 qc_dist = 1e3 qc1 = QuantumChannel("qc_r1_m12", tl, qc_atten, qc_dist) qc1.set_ends(r1, m12) qc2 = QuantumChannel("qc_r2_m12", tl, qc_atten, qc_dist) qc2.set_ends(r2, m12) # create quantum channels linking r2 and r3 to m2 qc3 = QuantumChannel("qc_r2_m23", tl, qc_atten, qc_dist) qc3.set_ends(r2, m23) qc4 = QuantumChannel("qc_r3_m23", tl, qc_atten, qc_dist) qc4.set_ends(r3, m23) tl.init() # load rules rule1 = Rule(10, eg_rule_action_f1_1, eg_rule_condition_f1) r1.resource_manager.load(rule1) rule2 = Rule(10, eg_rule_action_f1_2, eg_rule_condition_f1) r2.resource_manager.load(rule2) for i in range(3): add_eg_rules(i, [r1, r2, r3], [m12, m23]) add_ep_rules(i, [r1, r2, r3], 0.9) add_es_rules(i, [r1, r2, r3], 0.9, 1, 1) tl.run() print("Router 1 Memories") print("Index:\tEntangled Node:\tFidelity:\tEntanglement Time:") for i, info in enumerate(r1.resource_manager.memory_manager): print("{:6}\t{:15}\t{:9}\t{}".format(str(i), str(info.remote_node),