diff --git a/quisp/modules/QRSA/RuleEngine/RuleEngine.cc b/quisp/modules/QRSA/RuleEngine/RuleEngine.cc index f6a29519a..3e8bbdd5a 100644 --- a/quisp/modules/QRSA/RuleEngine/RuleEngine.cc +++ b/quisp/modules/QRSA/RuleEngine/RuleEngine.cc @@ -529,46 +529,6 @@ void RuleEngine::Unlock_resource_and_upgrade_stage(unsigned long ruleset_id, uns } } -void RuleEngine::updateAppliedRule(IStationaryQubit *qubit, unsigned long rule_id) { - // find there is a key - auto iter = applied_rules.find(qubit); - if (iter != applied_rules.end()) { - // qubit key found; - iter->second.push_back(rule_id); - } else { - std::vector rule_vector = {rule_id}; - applied_rules.insert(std::make_pair(qubit, rule_vector)); - } -} - -bool RuleEngine::checkAppliedRule(IStationaryQubit *qubit, unsigned long rule_id) { - // check if the rule can be applied (target rule id is not in the applied rules) - for (auto &rules : applied_rules) { - if (rules.first == qubit) { - for (auto &rule : rules.second) { - // if the rule exists, this rule is already applied, so you cannot apply any more. - if (rule == rule_id) { - return false; - } - } - // if not, you can go ahead to apply the rule - return true; - } - } - // completely fresh resource - return true; -} - -void RuleEngine::clearAppliedRule(IStationaryQubit *qubit) { - // erase the record when the qubit is initialized - auto iter = applied_rules.find(qubit); - if (iter != applied_rules.end()) { - applied_rules.erase(iter); - } else { - error("No rule record found at clearing"); - } -} - void RuleEngine::Unlock_resource_and_discard(unsigned long ruleset_id, unsigned long rule_id, int index) { bool ok = false; auto ruleset_result = rp.findById(ruleset_id); @@ -1061,16 +1021,14 @@ void RuleEngine::ResourceAllocation(int qnic_type, int qnic_index) { auto *qubit = provider.getStationaryQubit(qubit_record); // 3. if the qubit is not allocated yet, and the qubit has not been allocated to this rule, // if the qubit has already been assigned to the rule, the qubit is not allocatable to that rule - bool allocatable = checkAppliedRule(qubit, (*rule)->rule_id); - // EV<<" allocatable: "<isAllocated() && allocatable) { + if (!qubit_record->isAllocated() && !qubit_record->isRuleApplied((*rule)->rule_id)) { if (qubit->entangled_partner == nullptr && qubit->Density_Matrix_Collapsed(0, 0).real() == -111 && !qubit->no_density_matrix_nullptr_entangled_partner_ok) { error("Freshing qubit wrong"); } // 5. increment the assined counter and set allocated flag assigned++; qubit_record->setAllocated(true); - updateAppliedRule(qubit, (*rule)->rule_id); + qubit_record->markRuleApplied((*rule)->rule_id); (*rule)->addResource(action_partner, qubit); } } @@ -1244,8 +1202,10 @@ void RuleEngine::freeConsumedResource(int qnic_index /*Not the address!!!*/, ISt auto *qubit_record = qnic_store->getQubitRecord(qnic_type, qnic_index, qubit->par("stationaryQubit_address")); realtime_controller->ReInitialize_StationaryQubit(qubit_record, false); qubit_record->setBusy(false); - if (qubit_record->isAllocated()) qubit_record->setAllocated(false); - clearAppliedRule(qubit); + if (qubit_record->isAllocated()) { + qubit_record->setAllocated(false); + } + qubit_record->clearAppliedRules(); bell_pair_store.eraseQubit(qubit_record); } diff --git a/quisp/modules/QRSA/RuleEngine/RuleEngine.h b/quisp/modules/QRSA/RuleEngine/RuleEngine.h index 6cc4dee9a..1865194ac 100644 --- a/quisp/modules/QRSA/RuleEngine/RuleEngine.h +++ b/quisp/modules/QRSA/RuleEngine/RuleEngine.h @@ -21,6 +21,7 @@ #include "modules/QRSA/HardwareMonitor/HardwareMonitor.h" #include "modules/QRSA/RealTimeController/IRealTimeController.h" #include "modules/QRSA/RoutingDaemon/RoutingDaemon.h" +#include "modules/QRSA/RuleEngine/QubitRecord/IQubitRecord.h" #include "modules/QUBIT.h" #include "utils/ComponentProvider.h" @@ -30,6 +31,7 @@ namespace quisp { namespace modules { using namespace rules; using qnic_store::IQNicStore; +using qubit_record::IQubitRecord; /** \class RuleEngine RuleEngine.h * \note The Connection Manager responds to connection requests received from other nodes. @@ -74,8 +76,6 @@ class RuleEngine : public IRuleEngine { // when the tracker for the qnic is clered by previous BSM trial it goes true // when the RuleEngine try to start new Photon emittion, it goes false and other BSM trial can't access to it. std::vector tracker_accessible; - // tracking the rules that have been applied to the qubit - std::map> applied_rules; // void freeResource(int qnic_index, int qubit_index, QNIC_type qnic_type) override; void freeConsumedResource(int qnic_index, IStationaryQubit *qubit, QNIC_type qnic_type) override; @@ -109,9 +109,6 @@ class RuleEngine : public IRuleEngine { void Unlock_resource_and_upgrade_stage(unsigned long ruleset_id, unsigned long rule_id, int index); void Unlock_resource_and_discard(unsigned long ruleset_id, unsigned long rule_id, int index); - void updateAppliedRule(IStationaryQubit *qubit, unsigned long rule_id); - bool checkAppliedRule(IStationaryQubit *qubit, unsigned long rule_id); - void clearAppliedRule(IStationaryQubit *qubit); void updateResources_EntanglementSwapping(swapping_result swapr); virtual void updateResources_SimultaneousEntanglementSwapping(swapping_result swapr); diff --git a/quisp/modules/QRSA/RuleEngine/RuleEngine_test.cc b/quisp/modules/QRSA/RuleEngine/RuleEngine_test.cc index bd0377282..cd97572a2 100644 --- a/quisp/modules/QRSA/RuleEngine/RuleEngine_test.cc +++ b/quisp/modules/QRSA/RuleEngine/RuleEngine_test.cc @@ -61,15 +61,12 @@ class Strategy : public quisp_test::TestComponentProviderStrategy { class RuleEngineTestTarget : public quisp::modules::RuleEngine { public: - using quisp::modules::RuleEngine::checkAppliedRule; - using quisp::modules::RuleEngine::clearAppliedRule; using quisp::modules::RuleEngine::initialize; using quisp::modules::RuleEngine::par; using quisp::modules::RuleEngine::qnic_store; using quisp::modules::RuleEngine::storeCheck_Purification_Agreement; using quisp::modules::RuleEngine::Unlock_resource_and_discard; using quisp::modules::RuleEngine::Unlock_resource_and_upgrade_stage; - using quisp::modules::RuleEngine::updateAppliedRule; using quisp::modules::RuleEngine::updateResources_EntanglementSwapping; RuleEngineTestTarget(IStationaryQubit* mockQubit, MockRoutingDaemon* routingdaemon, MockHardwareMonitor* hardware_monitor, MockRealTimeController* realtime_controller, @@ -161,11 +158,10 @@ TEST(RuleEngineTest, resourceAllocation) { auto* sim = prepareSimulation(); auto* routingdaemon = new MockRoutingDaemon; auto* mockHardwareMonitor = new MockHardwareMonitor; - auto* mockQubit1 = new MockQubit(QNIC_E, 3); auto* qubit_record0 = new QubitRecord(QNIC_E, 3, 0); auto* qubit_record1 = new QubitRecord(QNIC_E, 3, 1); auto* qubit_record2 = new QubitRecord(QNIC_E, 3, 2); - auto rule_engine = new RuleEngineTestTarget{mockQubit1, routingdaemon, mockHardwareMonitor, nullptr, qnic_specs}; + auto rule_engine = new RuleEngineTestTarget{nullptr, routingdaemon, mockHardwareMonitor, nullptr, qnic_specs}; sim->registerComponent(rule_engine); rule_engine->callInitialize(); rule_engine->setAllResources(0, qubit_record0); @@ -193,7 +189,6 @@ TEST(RuleEngineTest, resourceAllocation) { EXPECT_EQ(_rule->resources.size(), 1); delete mockHardwareMonitor; delete routingdaemon; - delete mockQubit1; } TEST(RuleEngineTest, trackerUpdate) { @@ -306,13 +301,13 @@ TEST(RuleEngineTest, freeConsumedResource) { auto* qubit_record = new QubitRecord(QNIC_E, qnic_index, 1); qubit_record->setBusy(true); qubit->fillParams(); - rule_engine->updateAppliedRule(qubit, 0); - EXPECT_FALSE(rule_engine->checkAppliedRule(qubit, 0)); + qubit_record->markRuleApplied(0); + EXPECT_FALSE(!qubit_record->isRuleApplied(0)); EXPECT_CALL(*realtime_controller, ReInitialize_StationaryQubit(qubit_record, false)).Times(1).WillOnce(Return()); EXPECT_CALL(*dynamic_cast(rule_engine->qnic_store.get()), getQubitRecord(QNIC_E, qnic_index, 1)).Times(1).WillOnce(Return(qubit_record)); rule_engine->freeConsumedResource(qnic_index, qubit, QNIC_E); - EXPECT_TRUE(rule_engine->checkAppliedRule(qubit, 0)); + EXPECT_TRUE(!qubit_record->isRuleApplied(0)); EXPECT_FALSE(qubit_record->isBusy()); delete qubit; delete hardware_monitor; @@ -351,7 +346,7 @@ TEST(RuleEngineTest, unlockResourceAndDiscard) { EXPECT_CALL(*qubit, Unlock()).Times(1); EXPECT_CALL(*dynamic_cast(rule_engine->qnic_store.get()), getQubitRecord(QNIC_E, qnic_index, 1)).Times(1).WillOnce(Return(qubit_record)); - rule_engine->updateAppliedRule(qubit, 0); + qubit_record->markRuleApplied(0); EXPECT_EQ(rule1->resources.size(), 1); EXPECT_EQ(rule2->resources.size(), 0); EXPECT_CALL(*realtime_controller, ReInitialize_StationaryQubit(qubit_record, false)).Times(1).WillOnce(Return()); @@ -460,16 +455,14 @@ TEST(RuleEngineTest, updateAndCheckAppliedRule) { auto* rule_engine = new RuleEngineTestTarget{nullptr, routing_daemon, hardware_monitor, realtime_controller, qnic_specs}; rule_engine->callInitialize(); - auto* qubit1 = new MockQubit(QNIC_E, 7); - auto* qubit2 = new MockQubit(QNIC_E, 11); - EXPECT_TRUE(rule_engine->checkAppliedRule(qubit1, 1)); - rule_engine->updateAppliedRule(qubit1, 1); - EXPECT_FALSE(rule_engine->checkAppliedRule(qubit1, 1)); - EXPECT_TRUE(rule_engine->checkAppliedRule(qubit1, 2)); - EXPECT_TRUE(rule_engine->checkAppliedRule(qubit2, 1)); + auto* qubit_record1 = new QubitRecord(QNIC_E, 7, 0); + auto* qubit_record2 = new QubitRecord(QNIC_E, 11, 0); + EXPECT_TRUE(!qubit_record1->isRuleApplied(1)); + qubit_record1->markRuleApplied(1); + EXPECT_FALSE(!qubit_record1->isRuleApplied(1)); + EXPECT_TRUE(!qubit_record1->isRuleApplied(2)); + EXPECT_TRUE(!qubit_record2->isRuleApplied(1)); - delete qubit1; - delete qubit2; delete hardware_monitor; } @@ -482,14 +475,16 @@ TEST(RuleEngineTest, checkAppliedRule) { rule_engine->callInitialize(); auto* qubit = new MockQubit(QNIC_E, 7); - EXPECT_TRUE(rule_engine->checkAppliedRule(qubit, 1)); - rule_engine->updateAppliedRule(qubit, 1); - EXPECT_FALSE(rule_engine->checkAppliedRule(qubit, 1)); + auto* qubit_record = new QubitRecord(QNIC_E, 7, 1); + EXPECT_TRUE(!qubit_record->isRuleApplied(1)); + qubit_record->markRuleApplied(1); + EXPECT_FALSE(!qubit_record->isRuleApplied(1)); - rule_engine->clearAppliedRule(qubit); - EXPECT_TRUE(rule_engine->checkAppliedRule(qubit, 1)); + qubit_record->clearAppliedRules(); + EXPECT_TRUE(!qubit_record->isRuleApplied(1)); delete qubit; + delete qubit_record; delete hardware_monitor; }