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),
