4329255112

Build Type

github

Committed by GitHub

Commit Message

Merge 948c96a03 into 3166d7e57

Pull Request Pull Request #504: Integrate Message Exchange (Purification/Entanglement Swapping) into RuleSet and Runtime

Run Details

957 of 957 new or added lines in 22 files covered. (100.0%)

2287 of 5806 relevant lines covered (39.39%)

46937.47 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.74

/quisp/modules/QRSA/RuleEngine/RuntimeCallback.h

#pragma once

#include <omnetpp.h>
#include <sstream>
#include <stdexcept>

#include <messages/classical_messages.h>
#include <runtime/Runtime.h>
#include <runtime/types.h>
#include <utils/ComponentProvider.h>

#include "RuleEngine.h"
#include "modules/QNIC/StationaryQubit/IStationaryQubit.h"
#include "modules/QRSA/RuleEngine/QubitRecord/IQubitRecord.h"

namespace quisp::modules::runtime_callback {

using namespace quisp::runtime;
using quisp::modules::RuleEngine;
using quisp::runtime::QNodeAddr;
using namespace quisp::messages;

struct RuntimeCallback : public quisp::runtime::Runtime::ICallBack {
  RuntimeCallback(RuleEngine *re) : rule_engine(re), provider(re->provider) {}

  MeasurementOutcome measureQubitRandomly(IQubitRecord *qubit_rec) override {
    auto qubit = provider.getStationaryQubit(qubit_rec);
    return qubit->measureRandomPauliBasis();
  }

  MeasurementOutcome measureQubitX(IQubitRecord *qubit_rec) override {
    auto qubit = provider.getStationaryQubit(qubit_rec);
    return MeasurementOutcome{.basis = 'X', .outcome_is_plus = qubit->measureX() == types::EigenvalueResult::PLUS_ONE};
  }

  MeasurementOutcome measureQubitZ(IQubitRecord *qubit_rec) override {
    auto qubit = provider.getStationaryQubit(qubit_rec);
    return MeasurementOutcome{.basis = 'Z', .outcome_is_plus = qubit->measureZ() == types::EigenvalueResult::PLUS_ONE};
  }

  MeasurementOutcome measureQubitY(IQubitRecord *qubit_rec) override {
    auto qubit = provider.getStationaryQubit(qubit_rec);
    return MeasurementOutcome{.basis = 'Y', .outcome_is_plus = qubit->measureY() == types::EigenvalueResult::PLUS_ONE};
  }

  void gateX(IQubitRecord *qubit_rec) override {
    auto *qubit = provider.getStationaryQubit(qubit_rec);
    assert(qubit != nullptr);
    qubit->gateX();
  }

  void gateZ(IQubitRecord *qubit_rec) override {
    auto *qubit = provider.getStationaryQubit(qubit_rec);
    assert(qubit != nullptr);
    qubit->gateZ();
  }

  void gateY(IQubitRecord *qubit_rec) override {
    auto *qubit = provider.getStationaryQubit(qubit_rec);
    assert(qubit != nullptr);
    qubit->gateY();
  }

  void gateCNOT(IQubitRecord *control_qubit_rec, IQubitRecord *target_qubit_rec) override {
    auto *control_qubit = provider.getStationaryQubit(control_qubit_rec);
    auto *target_qubit = provider.getStationaryQubit(target_qubit_rec);
    assert(control_qubit != nullptr);
    assert(target_qubit != nullptr);
    control_qubit->gateCNOT(target_qubit);
  }

  int purifyX(IQubitRecord *qubit_rec, IQubitRecord *trash_qubit_rec) override {
    auto *qubit = provider.getStationaryQubit(qubit_rec);
    auto *trash_qubit = provider.getStationaryQubit(trash_qubit_rec);
    assert(qubit != nullptr);
    assert(trash_qubit != nullptr);
    qubit->gateCNOT(trash_qubit);
    return trash_qubit->measureZ() == types::EigenvalueResult::PLUS_ONE ? 0 : 1;
  }

  int purifyZ(IQubitRecord *qubit_rec, IQubitRecord *trash_qubit_rec) override {
    auto *qubit = provider.getStationaryQubit(qubit_rec);
    auto *trash_qubit = provider.getStationaryQubit(trash_qubit_rec);
    assert(qubit != nullptr);
    assert(trash_qubit != nullptr);
    trash_qubit->gateCNOT(qubit);
    return trash_qubit->measureX() == types::EigenvalueResult::PLUS_ONE ? 0 : 1;
  }

  int purifyY(IQubitRecord *qubit_rec, IQubitRecord *trash_qubit_rec) override {
    auto *qubit = provider.getStationaryQubit(qubit_rec);
    auto *trash_qubit = provider.getStationaryQubit(trash_qubit_rec);
    assert(qubit != nullptr);
    assert(trash_qubit != nullptr);

    trash_qubit->gateSdg();
    qubit->gateSdg();
    trash_qubit->gateCNOT(qubit);
    qubit->gateS();
    return trash_qubit->measureX() == types::EigenvalueResult::PLUS_ONE ? 0 : 1;
  }

  void sendLinkTomographyResult(const unsigned long ruleset_id, const runtime::Rule &rule, const int action_index, const runtime::QNodeAddr partner_addr, int count,
                                MeasurementOutcome outcome, int max_count, SimTime start_time) override {
    LinkTomographyResult *pk = new LinkTomographyResult{"LinkTomographyResult"};
    auto src = rule_engine->parentAddress;
    pk->setSrcAddr(src);
    pk->setDestAddr(partner_addr.val);
    pk->setCount_id(count);
    pk->setPartner_address(src);  // Partner's partner is self/src
    pk->setKind(6);
    pk->setOutput_is_plus(outcome.outcome_is_plus);
    pk->setBasis(outcome.basis);
    pk->setGOD_clean(outcome.GOD_clean);
    if (count == max_count) {
      pk->setFinish(simTime() - start_time);
      pk->setMax_count(max_count);
    }
    // // The cPacket *pk is a single packet forwarded to the neighbor. But this node's HardwareMonitor also needs to store the result.
    LinkTomographyResult *pk_for_self = pk->dup();
    pk_for_self->setPartner_address(pk->getDestAddr());
    pk_for_self->setDestAddr(pk->getSrcAddr());
    rule_engine->send(pk, "RouterPort$o");
    rule_engine->send(pk_for_self, "RouterPort$o");
  }

  void sendPurificationResult(const unsigned long ruleset_id, const QNodeAddr partner_addr, const int shared_rule_tag, const int sequence_number, const int measurement_result,
                              PurType protocol) override {
    auto *pkt = new PurificationResult{"PurificationResult"};
    pkt->setSrcAddr(rule_engine->parentAddress);
    pkt->setDestAddr(partner_addr.val);
    pkt->setKind(7);
    pkt->setRulesetId(ruleset_id);
    pkt->setSharedRuleTag(shared_rule_tag);
    pkt->setSequenceNumber(sequence_number);
    pkt->setMeasurementResult(measurement_result);
    pkt->setProtocol(protocol);
    auto *pk_for_self = pkt->dup();
    pk_for_self->setDestAddr(rule_engine->parentAddress);
    rule_engine->send(pkt, "RouterPort$o");
    rule_engine->send(pk_for_self, "RouterPort$o");
  }

  void sendSwappingResult(const unsigned long ruleset_id, const QNodeAddr partner_addr, const QNodeAddr new_partner_addr, const int shared_rule_tag, const int sequence_number,
                          const int frame_correction) override {
    SwappingResult *pkt = new SwappingResult("SwappingResult");
    pkt->setSrcAddr(rule_engine->parentAddress);
    pkt->setDestAddr(partner_addr.val);
    pkt->setRulesetId(ruleset_id);
    pkt->setSharedRuleTag(shared_rule_tag);
    pkt->setSequenceNumber(sequence_number);
    pkt->setKind(5);  // cyan
    pkt->setCorrectionFrame(frame_correction);
    pkt->setNewPartner(new_partner_addr.val);
    rule_engine->send(pkt, "RouterPort$o");
  }

  void freeAndResetQubit(IQubitRecord *qubit) override {
    auto *stat_qubit = rule_engine->provider.getStationaryQubit((qubit));
    rule_engine->freeConsumedResource(qubit->getQNicIndex(), stat_qubit, qubit->getQNicType());
  };

  bool isQubitLocked(IQubitRecord *const qubit_rec) override {
    auto *qubit = provider.getStationaryQubit(qubit_rec);
    return qubit->isLocked();
  }

  void lockQubit(IQubitRecord *const qubit_rec, unsigned long rs_id, int rule_id, int action_index) override {
    auto *qubit = provider.getStationaryQubit(qubit_rec);
    qubit->Lock(rs_id, rule_id, action_index);
  }
  int getActionIndex(IQubitRecord *const qubit_rec) override {
    auto *qubit = provider.getStationaryQubit(qubit_rec);
    return qubit->action_index;
  }

  std::string getNodeInfo() override {
    std::stringstream ss;
    ss << "QNodeAddr:" << std::to_string(rule_engine->parentAddress) << ", event #" << std::to_string(omnetpp::getSimulation()->getEventNumber());
    return ss.str();
  }

  RuleEngine *rule_engine;
  utils::ComponentProvider &provider;
  int right_qubit_index = -1;
  int left_qubit_index = -1;
};

}  // namespace quisp::modules::runtime_callback

1	#pragma once
2
3	#include <omnetpp.h>
4	#include <sstream>
5	#include <stdexcept>
6
7	#include <messages/classical_messages.h>
8	#include <runtime/Runtime.h>
9	#include <runtime/types.h>
10	#include <utils/ComponentProvider.h>
11
12	#include "RuleEngine.h"
13	#include "modules/QNIC/StationaryQubit/IStationaryQubit.h"
14	#include "modules/QRSA/RuleEngine/QubitRecord/IQubitRecord.h"
15
16	namespace quisp::modules::runtime_callback {
17
18	using namespace quisp::runtime;
19	using quisp::modules::RuleEngine;
20	using quisp::runtime::QNodeAddr;
21	using namespace quisp::messages;
22
23	struct RuntimeCallback : public quisp::runtime::Runtime::ICallBack {
24	RuntimeCallback(RuleEngine *re) : rule_engine(re), provider(re->provider) {}	6✔
25
26	MeasurementOutcome measureQubitRandomly(IQubitRecord *qubit_rec) override {	×
27	auto qubit = provider.getStationaryQubit(qubit_rec);	×
28	return qubit->measureRandomPauliBasis();	×
29	}	×
30
31	MeasurementOutcome measureQubitX(IQubitRecord *qubit_rec) override {	×
32	auto qubit = provider.getStationaryQubit(qubit_rec);	×
33	return MeasurementOutcome{.basis = 'X', .outcome_is_plus = qubit->measureX() == types::EigenvalueResult::PLUS_ONE};	×
34	}	×
35
36	MeasurementOutcome measureQubitZ(IQubitRecord *qubit_rec) override {	×
37	auto qubit = provider.getStationaryQubit(qubit_rec);	×
38	return MeasurementOutcome{.basis = 'Z', .outcome_is_plus = qubit->measureZ() == types::EigenvalueResult::PLUS_ONE};	×
39	}	×
40
41	MeasurementOutcome measureQubitY(IQubitRecord *qubit_rec) override {	×
42	auto qubit = provider.getStationaryQubit(qubit_rec);	×
43	return MeasurementOutcome{.basis = 'Y', .outcome_is_plus = qubit->measureY() == types::EigenvalueResult::PLUS_ONE};	×
44	}	×
45
46	void gateX(IQubitRecord *qubit_rec) override {	×
47	auto *qubit = provider.getStationaryQubit(qubit_rec);	×
48	assert(qubit != nullptr);	×
49	qubit->gateX();	×
50	}	×
51
52	void gateZ(IQubitRecord *qubit_rec) override {	×
53	auto *qubit = provider.getStationaryQubit(qubit_rec);	×
54	assert(qubit != nullptr);	×
55	qubit->gateZ();	×
56	}	×
57
58	void gateY(IQubitRecord *qubit_rec) override {	×
59	auto *qubit = provider.getStationaryQubit(qubit_rec);	×
60	assert(qubit != nullptr);	×
61	qubit->gateY();	×
62	}	×
63
64	void gateCNOT(IQubitRecord control_qubit_rec, IQubitRecord target_qubit_rec) override {	×
65	auto *control_qubit = provider.getStationaryQubit(control_qubit_rec);	×
66	auto *target_qubit = provider.getStationaryQubit(target_qubit_rec);	×
67	assert(control_qubit != nullptr);	×
68	assert(target_qubit != nullptr);	×
69	control_qubit->gateCNOT(target_qubit);	×
70	}	×
71
72	int purifyX(IQubitRecord qubit_rec, IQubitRecord trash_qubit_rec) override {	×
73	auto *qubit = provider.getStationaryQubit(qubit_rec);	×
74	auto *trash_qubit = provider.getStationaryQubit(trash_qubit_rec);	×
75	assert(qubit != nullptr);	×
76	assert(trash_qubit != nullptr);	×
77	qubit->gateCNOT(trash_qubit);	×
78	return trash_qubit->measureZ() == types::EigenvalueResult::PLUS_ONE ? 0 : 1;	×
79	}	×
80
81	int purifyZ(IQubitRecord qubit_rec, IQubitRecord trash_qubit_rec) override {	×
82	auto *qubit = provider.getStationaryQubit(qubit_rec);	×
83	auto *trash_qubit = provider.getStationaryQubit(trash_qubit_rec);	×
84	assert(qubit != nullptr);	×
85	assert(trash_qubit != nullptr);	×
86	trash_qubit->gateCNOT(qubit);	×
87	return trash_qubit->measureX() == types::EigenvalueResult::PLUS_ONE ? 0 : 1;	×
88	}	×
89
90	int purifyY(IQubitRecord qubit_rec, IQubitRecord trash_qubit_rec) override {	×
91	auto *qubit = provider.getStationaryQubit(qubit_rec);	×
92	auto *trash_qubit = provider.getStationaryQubit(trash_qubit_rec);	×
93	assert(qubit != nullptr);	×
94	assert(trash_qubit != nullptr);	×
95
96	trash_qubit->gateSdg();	×
97	qubit->gateSdg();	×
98	trash_qubit->gateCNOT(qubit);	×
99	qubit->gateS();	×
100	return trash_qubit->measureX() == types::EigenvalueResult::PLUS_ONE ? 0 : 1;	×
101	}	×
102
103	void sendLinkTomographyResult(const unsigned long ruleset_id, const runtime::Rule &rule, const int action_index, const runtime::QNodeAddr partner_addr, int count,
104	MeasurementOutcome outcome, int max_count, SimTime start_time) override {	×
105	LinkTomographyResult *pk = new LinkTomographyResult{"LinkTomographyResult"};	×
106	auto src = rule_engine->parentAddress;	×
107	pk->setSrcAddr(src);	×
108	pk->setDestAddr(partner_addr.val);	×
109	pk->setCount_id(count);	×
110	pk->setPartner_address(src); // Partner's partner is self/src	×
111	pk->setKind(6);	×
112	pk->setOutput_is_plus(outcome.outcome_is_plus);	×
113	pk->setBasis(outcome.basis);	×
114	pk->setGOD_clean(outcome.GOD_clean);	×
115	if (count == max_count) {	×
116	pk->setFinish(simTime() - start_time);	×
117	pk->setMax_count(max_count);	×
118	}	×
119	// // The cPacket *pk is a single packet forwarded to the neighbor. But this node's HardwareMonitor also needs to store the result.
120	LinkTomographyResult *pk_for_self = pk->dup();	×
121	pk_for_self->setPartner_address(pk->getDestAddr());	×
122	pk_for_self->setDestAddr(pk->getSrcAddr());	×
123	rule_engine->send(pk, "RouterPort$o");	×
124	rule_engine->send(pk_for_self, "RouterPort$o");	×
125	}	×
126
127	void sendPurificationResult(const unsigned long ruleset_id, const QNodeAddr partner_addr, const int shared_rule_tag, const int sequence_number, const int measurement_result,
128	PurType protocol) override {	×
129	auto *pkt = new PurificationResult{"PurificationResult"};	×
130	pkt->setSrcAddr(rule_engine->parentAddress);	×
131	pkt->setDestAddr(partner_addr.val);	×
132	pkt->setKind(7);	×
133	pkt->setRulesetId(ruleset_id);	×
134	pkt->setSharedRuleTag(shared_rule_tag);	×
135	pkt->setSequenceNumber(sequence_number);	×
136	pkt->setMeasurementResult(measurement_result);	×
137	pkt->setProtocol(protocol);	×
138	auto *pk_for_self = pkt->dup();	×
139	pk_for_self->setDestAddr(rule_engine->parentAddress);	×
140	rule_engine->send(pkt, "RouterPort$o");	×
141	rule_engine->send(pk_for_self, "RouterPort$o");	×
142	}	×
143
144	void sendSwappingResult(const unsigned long ruleset_id, const QNodeAddr partner_addr, const QNodeAddr new_partner_addr, const int shared_rule_tag, const int sequence_number,
145	const int frame_correction) override {	×
146	SwappingResult *pkt = new SwappingResult("SwappingResult");	×
147	pkt->setSrcAddr(rule_engine->parentAddress);	×
148	pkt->setDestAddr(partner_addr.val);	×
149	pkt->setRulesetId(ruleset_id);	×
150	pkt->setSharedRuleTag(shared_rule_tag);	×
151	pkt->setSequenceNumber(sequence_number);	×
152	pkt->setKind(5); // cyan	×
153	pkt->setCorrectionFrame(frame_correction);	×
154	pkt->setNewPartner(new_partner_addr.val);	×
155	rule_engine->send(pkt, "RouterPort$o");	×
156	}	×
157
158	void freeAndResetQubit(IQubitRecord *qubit) override {	×
159	auto *stat_qubit = rule_engine->provider.getStationaryQubit((qubit));	×
160	rule_engine->freeConsumedResource(qubit->getQNicIndex(), stat_qubit, qubit->getQNicType());	×
161	};	×
162
163	bool isQubitLocked(IQubitRecord *const qubit_rec) override {	×
164	auto *qubit = provider.getStationaryQubit(qubit_rec);	×
165	return qubit->isLocked();	×
166	}	×
167
168	void lockQubit(IQubitRecord *const qubit_rec, unsigned long rs_id, int rule_id, int action_index) override {	×
169	auto *qubit = provider.getStationaryQubit(qubit_rec);	×
170	qubit->Lock(rs_id, rule_id, action_index);	×
171	}	×
172	int getActionIndex(IQubitRecord *const qubit_rec) override {	×
173	auto *qubit = provider.getStationaryQubit(qubit_rec);	×
174	return qubit->action_index;	×
175	}	×
176
177	std::string getNodeInfo() override {	×
178	std::stringstream ss;	×
179	ss << "QNodeAddr:" << std::to_string(rule_engine->parentAddress) << ", event #" << std::to_string(omnetpp::getSimulation()->getEventNumber());	×
180	return ss.str();	×
181	}	×
182
183	RuleEngine *rule_engine;
184	utils::ComponentProvider &provider;
185	int right_qubit_index = -1;
186	int left_qubit_index = -1;
187	};
188
189	} // namespace quisp::modules::runtime_callback

sfc-aqua / quisp / 4329255112

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous