diff --git a/benchmarks/model_checking_opreuse/C++/CAN_BUS_tlc.cpp b/benchmarks/model_checking_opreuse/C++/CAN_BUS_tlc.cpp index 2b84558ed2c79c7cf7246ec51abf1678a646139f..90f2443cb4c8d082782bf1aed818cd6106fa69b9 100644 --- a/benchmarks/model_checking_opreuse/C++/CAN_BUS_tlc.cpp +++ b/benchmarks/model_checking_opreuse/C++/CAN_BUS_tlc.cpp @@ -10,7 +10,6 @@ #include <atomic> #include <any> #include <mutex> -#include <shared_mutex> #include <future> #include <boost/asio/post.hpp> #include <boost/asio/thread_pool.hpp> @@ -6101,12 +6100,16 @@ class ModelChecker { states.insert(machine); unvisitedStates.push_back(machine); - std::atomic<bool> stopThreads(false); + std::atomic<bool> stopThreads; + stopThreads = false; std::atomic<int> possibleQueueChanges; possibleQueueChanges = 0; - while(!unvisitedStates.empty() && !stopThreads.load()) { - possibleQueueChanges.fetch_add(1); + std::atomic<bool> waitFlag; + waitFlag = true; + + while(!unvisitedStates.empty() && !stopThreads) { + possibleQueueChanges += 1; CAN_BUS_tlc state = next(); std::packaged_task<void()> task([&, state] { std::unordered_set<CAN_BUS_tlc, CAN_BUS_tlc::Hash, CAN_BUS_tlc::HashEqual> nextStates = generateNextStates(state); @@ -6127,12 +6130,14 @@ class ModelChecker { } } - possibleQueueChanges.fetch_sub(1); { std::unique_lock<std::mutex> lock(mutex); - if (!unvisitedStates.empty() || possibleQueueChanges.load() == 0) { + possibleQueueChanges -= 1; + int running = possibleQueueChanges; + if (!unvisitedStates.empty() || running == 0) { { std::unique_lock<std::mutex> lock(waitMutex); + waitFlag = false; waitCV.notify_one(); } } @@ -6142,24 +6147,27 @@ class ModelChecker { if(invariantViolated(state)) { invariantViolatedBool = true; counterExampleState = state; - stopThreads.store(true); + stopThreads = true; } if(nextStates.empty()) { deadlockDetected = true; counterExampleState = state; - stopThreads.store(true); + stopThreads = true; } }); + waitFlag = true; boost::asio::post(workers, std::move(task)); { std::unique_lock<std::mutex> lock(waitMutex); - waitCV.wait(lock, [&] { - return !unvisitedStates.empty() || possibleQueueChanges == 0; - }); + if(unvisitedStates.empty() && possibleQueueChanges > 0) { + waitCV.wait(lock, [&] { + return waitFlag == false; + }); + } } } workers.join(); @@ -6248,262 +6256,168 @@ class ModelChecker { copiedState.stateAccessedVia = "T1Evaluate"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } CAN_BUS_tlc::_ProjectionRead__tr_T1Calculate read__tr_T1Calculate_state = state._projected_state_for__tr_T1Calculate(); + BSet<BInteger> _trid_2; auto _trid_2_ptr = _OpCache_tr_T1Calculate.find(read__tr_T1Calculate_state); if(_trid_2_ptr == _OpCache_tr_T1Calculate.end()) { - BSet<BInteger> _trid_2 = state._tr_T1Calculate(); + _trid_2 = state._tr_T1Calculate(); { std::unique_lock<std::mutex> _ProjectionRead__tr_T1Calculate_lock(_ProjectionRead__tr_T1Calculate_mutex); _OpCache_tr_T1Calculate.insert({read__tr_T1Calculate_state, _trid_2}); } - for(const BInteger& param : _trid_2) { - BInteger _tmp_1 = param; - - CAN_BUS_tlc copiedState = state._copy(); - CAN_BUS_tlc::_ProjectionRead_T1Calculate readState = state._projected_state_for_T1Calculate(); + } else { + _trid_2 = _trid_2_ptr->second; + } - auto _OpCache_with_parameter_T1Calculate_ptr = _OpCache_T1Calculate.find(param); - if(_OpCache_with_parameter_T1Calculate_ptr == _OpCache_T1Calculate.end()) { - copiedState.T1Calculate(_tmp_1); - CAN_BUS_tlc::_ProjectionWrite_T1Calculate writeState = copiedState._update_for_T1Calculate(); - std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T1Calculate, CAN_BUS_tlc::_ProjectionWrite_T1Calculate, CAN_BUS_tlc::_ProjectionRead_T1Calculate::Hash, CAN_BUS_tlc::_ProjectionRead_T1Calculate::HashEqual> _OpCache_with_parameter_T1Calculate; - _OpCache_with_parameter_T1Calculate.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_T1Calculate_lock(_ProjectionRead_T1Calculate_mutex); - _OpCache_T1Calculate.insert({param, _OpCache_with_parameter_T1Calculate}); - } + for(const BInteger& param : _trid_2) { + BInteger _tmp_1 = param; - } else { - std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T1Calculate, CAN_BUS_tlc::_ProjectionWrite_T1Calculate, CAN_BUS_tlc::_ProjectionRead_T1Calculate::Hash, CAN_BUS_tlc::_ProjectionRead_T1Calculate::HashEqual> _OpCache_with_parameter_T1Calculate = _OpCache_with_parameter_T1Calculate_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_T1Calculate.find(readState); - if(writeState_ptr != _OpCache_with_parameter_T1Calculate.end()) { - CAN_BUS_tlc::_ProjectionWrite_T1Calculate writeState = writeState_ptr->second; - copiedState._apply_update_for_T1Calculate(writeState); - } else { - copiedState.T1Calculate(_tmp_1); - CAN_BUS_tlc::_ProjectionWrite_T1Calculate writeState = copiedState._update_for_T1Calculate(); - { - std::unique_lock<std::mutex> _ProjectionRead_T1Calculate_lock(_ProjectionRead_T1Calculate_mutex); - _OpCache_with_parameter_T1Calculate.insert({readState, writeState}); - } - } + CAN_BUS_tlc copiedState = state._copy(); + CAN_BUS_tlc::_ProjectionRead_T1Calculate readState = state._projected_state_for_T1Calculate(); + + auto _OpCache_with_parameter_T1Calculate_ptr = _OpCache_T1Calculate.find(param); + if(_OpCache_with_parameter_T1Calculate_ptr == _OpCache_T1Calculate.end()) { + copiedState.T1Calculate(_tmp_1); + CAN_BUS_tlc::_ProjectionWrite_T1Calculate writeState = copiedState._update_for_T1Calculate(); + std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T1Calculate, CAN_BUS_tlc::_ProjectionWrite_T1Calculate, CAN_BUS_tlc::_ProjectionRead_T1Calculate::Hash, CAN_BUS_tlc::_ProjectionRead_T1Calculate::HashEqual> _OpCache_with_parameter_T1Calculate; + _OpCache_with_parameter_T1Calculate.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_T1Calculate_lock(_ProjectionRead_T1Calculate_mutex); + _OpCache_T1Calculate.insert({param, _OpCache_with_parameter_T1Calculate}); } - copiedState.stateAccessedVia = "T1Calculate"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<BInteger> _trid_2 = _trid_2_ptr->second; - for(const BInteger& param : _trid_2) { - BInteger _tmp_1 = param; - - CAN_BUS_tlc copiedState = state._copy(); - CAN_BUS_tlc::_ProjectionRead_T1Calculate readState = state._projected_state_for_T1Calculate(); - - auto _OpCache_with_parameter_T1Calculate_ptr = _OpCache_T1Calculate.find(param); - if(_OpCache_with_parameter_T1Calculate_ptr == _OpCache_T1Calculate.end()) { + } else { + std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T1Calculate, CAN_BUS_tlc::_ProjectionWrite_T1Calculate, CAN_BUS_tlc::_ProjectionRead_T1Calculate::Hash, CAN_BUS_tlc::_ProjectionRead_T1Calculate::HashEqual> _OpCache_with_parameter_T1Calculate = _OpCache_with_parameter_T1Calculate_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_T1Calculate.find(readState); + if(writeState_ptr != _OpCache_with_parameter_T1Calculate.end()) { + CAN_BUS_tlc::_ProjectionWrite_T1Calculate writeState = writeState_ptr->second; + copiedState._apply_update_for_T1Calculate(writeState); + } else { copiedState.T1Calculate(_tmp_1); CAN_BUS_tlc::_ProjectionWrite_T1Calculate writeState = copiedState._update_for_T1Calculate(); - std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T1Calculate, CAN_BUS_tlc::_ProjectionWrite_T1Calculate, CAN_BUS_tlc::_ProjectionRead_T1Calculate::Hash, CAN_BUS_tlc::_ProjectionRead_T1Calculate::HashEqual> _OpCache_with_parameter_T1Calculate; - _OpCache_with_parameter_T1Calculate.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_T1Calculate_lock(_ProjectionRead_T1Calculate_mutex); - _OpCache_T1Calculate.insert({param, _OpCache_with_parameter_T1Calculate}); - } - - } else { - std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T1Calculate, CAN_BUS_tlc::_ProjectionWrite_T1Calculate, CAN_BUS_tlc::_ProjectionRead_T1Calculate::Hash, CAN_BUS_tlc::_ProjectionRead_T1Calculate::HashEqual> _OpCache_with_parameter_T1Calculate = _OpCache_with_parameter_T1Calculate_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_T1Calculate.find(readState); - if(writeState_ptr != _OpCache_with_parameter_T1Calculate.end()) { - CAN_BUS_tlc::_ProjectionWrite_T1Calculate writeState = writeState_ptr->second; - copiedState._apply_update_for_T1Calculate(writeState); - } else { - copiedState.T1Calculate(_tmp_1); - CAN_BUS_tlc::_ProjectionWrite_T1Calculate writeState = copiedState._update_for_T1Calculate(); - { - std::unique_lock<std::mutex> _ProjectionRead_T1Calculate_lock(_ProjectionRead_T1Calculate_mutex); - _OpCache_with_parameter_T1Calculate.insert({readState, writeState}); - } + _OpCache_with_parameter_T1Calculate.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "T1Calculate"; - result.insert(copiedState); + copiedState.stateAccessedVia = "T1Calculate"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } CAN_BUS_tlc::_ProjectionRead__tr_T1SendResult read__tr_T1SendResult_state = state._projected_state_for__tr_T1SendResult(); + BSet<BTuple<BInteger, BInteger >> _trid_3; auto _trid_3_ptr = _OpCache_tr_T1SendResult.find(read__tr_T1SendResult_state); if(_trid_3_ptr == _OpCache_tr_T1SendResult.end()) { - BSet<BTuple<BInteger, BInteger >> _trid_3 = state._tr_T1SendResult(); + _trid_3 = state._tr_T1SendResult(); { std::unique_lock<std::mutex> _ProjectionRead__tr_T1SendResult_lock(_ProjectionRead__tr_T1SendResult_mutex); _OpCache_tr_T1SendResult.insert({read__tr_T1SendResult_state, _trid_3}); } - for(const BTuple<BInteger, BInteger >& param : _trid_3) { - BInteger _tmp_1 = param.projection2(); - BInteger _tmp_2 = param.projection1(); - - CAN_BUS_tlc copiedState = state._copy(); - CAN_BUS_tlc::_ProjectionRead_T1SendResult readState = state._projected_state_for_T1SendResult(); + } else { + _trid_3 = _trid_3_ptr->second; + } - auto _OpCache_with_parameter_T1SendResult_ptr = _OpCache_T1SendResult.find(param); - if(_OpCache_with_parameter_T1SendResult_ptr == _OpCache_T1SendResult.end()) { - copiedState.T1SendResult(_tmp_2, _tmp_1); - CAN_BUS_tlc::_ProjectionWrite_T1SendResult writeState = copiedState._update_for_T1SendResult(); - std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T1SendResult, CAN_BUS_tlc::_ProjectionWrite_T1SendResult, CAN_BUS_tlc::_ProjectionRead_T1SendResult::Hash, CAN_BUS_tlc::_ProjectionRead_T1SendResult::HashEqual> _OpCache_with_parameter_T1SendResult; - _OpCache_with_parameter_T1SendResult.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_T1SendResult_lock(_ProjectionRead_T1SendResult_mutex); - _OpCache_T1SendResult.insert({param, _OpCache_with_parameter_T1SendResult}); - } + for(const BTuple<BInteger, BInteger >& param : _trid_3) { + BInteger _tmp_1 = param.projection2(); + BInteger _tmp_2 = param.projection1(); - } else { - std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T1SendResult, CAN_BUS_tlc::_ProjectionWrite_T1SendResult, CAN_BUS_tlc::_ProjectionRead_T1SendResult::Hash, CAN_BUS_tlc::_ProjectionRead_T1SendResult::HashEqual> _OpCache_with_parameter_T1SendResult = _OpCache_with_parameter_T1SendResult_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_T1SendResult.find(readState); - if(writeState_ptr != _OpCache_with_parameter_T1SendResult.end()) { - CAN_BUS_tlc::_ProjectionWrite_T1SendResult writeState = writeState_ptr->second; - copiedState._apply_update_for_T1SendResult(writeState); - } else { - copiedState.T1SendResult(_tmp_2, _tmp_1); - CAN_BUS_tlc::_ProjectionWrite_T1SendResult writeState = copiedState._update_for_T1SendResult(); - { - std::unique_lock<std::mutex> _ProjectionRead_T1SendResult_lock(_ProjectionRead_T1SendResult_mutex); - _OpCache_with_parameter_T1SendResult.insert({readState, writeState}); - } - } + CAN_BUS_tlc copiedState = state._copy(); + CAN_BUS_tlc::_ProjectionRead_T1SendResult readState = state._projected_state_for_T1SendResult(); + + auto _OpCache_with_parameter_T1SendResult_ptr = _OpCache_T1SendResult.find(param); + if(_OpCache_with_parameter_T1SendResult_ptr == _OpCache_T1SendResult.end()) { + copiedState.T1SendResult(_tmp_2, _tmp_1); + CAN_BUS_tlc::_ProjectionWrite_T1SendResult writeState = copiedState._update_for_T1SendResult(); + std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T1SendResult, CAN_BUS_tlc::_ProjectionWrite_T1SendResult, CAN_BUS_tlc::_ProjectionRead_T1SendResult::Hash, CAN_BUS_tlc::_ProjectionRead_T1SendResult::HashEqual> _OpCache_with_parameter_T1SendResult; + _OpCache_with_parameter_T1SendResult.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_T1SendResult_lock(_ProjectionRead_T1SendResult_mutex); + _OpCache_T1SendResult.insert({param, _OpCache_with_parameter_T1SendResult}); } - copiedState.stateAccessedVia = "T1SendResult"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<BTuple<BInteger, BInteger >> _trid_3 = _trid_3_ptr->second; - for(const BTuple<BInteger, BInteger >& param : _trid_3) { - BInteger _tmp_1 = param.projection2(); - BInteger _tmp_2 = param.projection1(); - - CAN_BUS_tlc copiedState = state._copy(); - CAN_BUS_tlc::_ProjectionRead_T1SendResult readState = state._projected_state_for_T1SendResult(); - - auto _OpCache_with_parameter_T1SendResult_ptr = _OpCache_T1SendResult.find(param); - if(_OpCache_with_parameter_T1SendResult_ptr == _OpCache_T1SendResult.end()) { + } else { + std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T1SendResult, CAN_BUS_tlc::_ProjectionWrite_T1SendResult, CAN_BUS_tlc::_ProjectionRead_T1SendResult::Hash, CAN_BUS_tlc::_ProjectionRead_T1SendResult::HashEqual> _OpCache_with_parameter_T1SendResult = _OpCache_with_parameter_T1SendResult_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_T1SendResult.find(readState); + if(writeState_ptr != _OpCache_with_parameter_T1SendResult.end()) { + CAN_BUS_tlc::_ProjectionWrite_T1SendResult writeState = writeState_ptr->second; + copiedState._apply_update_for_T1SendResult(writeState); + } else { copiedState.T1SendResult(_tmp_2, _tmp_1); CAN_BUS_tlc::_ProjectionWrite_T1SendResult writeState = copiedState._update_for_T1SendResult(); - std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T1SendResult, CAN_BUS_tlc::_ProjectionWrite_T1SendResult, CAN_BUS_tlc::_ProjectionRead_T1SendResult::Hash, CAN_BUS_tlc::_ProjectionRead_T1SendResult::HashEqual> _OpCache_with_parameter_T1SendResult; - _OpCache_with_parameter_T1SendResult.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_T1SendResult_lock(_ProjectionRead_T1SendResult_mutex); - _OpCache_T1SendResult.insert({param, _OpCache_with_parameter_T1SendResult}); - } - - } else { - std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T1SendResult, CAN_BUS_tlc::_ProjectionWrite_T1SendResult, CAN_BUS_tlc::_ProjectionRead_T1SendResult::Hash, CAN_BUS_tlc::_ProjectionRead_T1SendResult::HashEqual> _OpCache_with_parameter_T1SendResult = _OpCache_with_parameter_T1SendResult_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_T1SendResult.find(readState); - if(writeState_ptr != _OpCache_with_parameter_T1SendResult.end()) { - CAN_BUS_tlc::_ProjectionWrite_T1SendResult writeState = writeState_ptr->second; - copiedState._apply_update_for_T1SendResult(writeState); - } else { - copiedState.T1SendResult(_tmp_2, _tmp_1); - CAN_BUS_tlc::_ProjectionWrite_T1SendResult writeState = copiedState._update_for_T1SendResult(); - { - std::unique_lock<std::mutex> _ProjectionRead_T1SendResult_lock(_ProjectionRead_T1SendResult_mutex); - _OpCache_with_parameter_T1SendResult.insert({readState, writeState}); - } + _OpCache_with_parameter_T1SendResult.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "T1SendResult"; - result.insert(copiedState); + copiedState.stateAccessedVia = "T1SendResult"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } CAN_BUS_tlc::_ProjectionRead__tr_T1Wait read__tr_T1Wait_state = state._projected_state_for__tr_T1Wait(); + BSet<BInteger> _trid_4; auto _trid_4_ptr = _OpCache_tr_T1Wait.find(read__tr_T1Wait_state); if(_trid_4_ptr == _OpCache_tr_T1Wait.end()) { - BSet<BInteger> _trid_4 = state._tr_T1Wait(); + _trid_4 = state._tr_T1Wait(); { std::unique_lock<std::mutex> _ProjectionRead__tr_T1Wait_lock(_ProjectionRead__tr_T1Wait_mutex); _OpCache_tr_T1Wait.insert({read__tr_T1Wait_state, _trid_4}); } - for(const BInteger& param : _trid_4) { - BInteger _tmp_1 = param; - - CAN_BUS_tlc copiedState = state._copy(); - CAN_BUS_tlc::_ProjectionRead_T1Wait readState = state._projected_state_for_T1Wait(); + } else { + _trid_4 = _trid_4_ptr->second; + } - auto _OpCache_with_parameter_T1Wait_ptr = _OpCache_T1Wait.find(param); - if(_OpCache_with_parameter_T1Wait_ptr == _OpCache_T1Wait.end()) { - copiedState.T1Wait(_tmp_1); - CAN_BUS_tlc::_ProjectionWrite_T1Wait writeState = copiedState._update_for_T1Wait(); - std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T1Wait, CAN_BUS_tlc::_ProjectionWrite_T1Wait, CAN_BUS_tlc::_ProjectionRead_T1Wait::Hash, CAN_BUS_tlc::_ProjectionRead_T1Wait::HashEqual> _OpCache_with_parameter_T1Wait; - _OpCache_with_parameter_T1Wait.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_T1Wait_lock(_ProjectionRead_T1Wait_mutex); - _OpCache_T1Wait.insert({param, _OpCache_with_parameter_T1Wait}); - } + for(const BInteger& param : _trid_4) { + BInteger _tmp_1 = param; - } else { - std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T1Wait, CAN_BUS_tlc::_ProjectionWrite_T1Wait, CAN_BUS_tlc::_ProjectionRead_T1Wait::Hash, CAN_BUS_tlc::_ProjectionRead_T1Wait::HashEqual> _OpCache_with_parameter_T1Wait = _OpCache_with_parameter_T1Wait_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_T1Wait.find(readState); - if(writeState_ptr != _OpCache_with_parameter_T1Wait.end()) { - CAN_BUS_tlc::_ProjectionWrite_T1Wait writeState = writeState_ptr->second; - copiedState._apply_update_for_T1Wait(writeState); - } else { - copiedState.T1Wait(_tmp_1); - CAN_BUS_tlc::_ProjectionWrite_T1Wait writeState = copiedState._update_for_T1Wait(); - { - std::unique_lock<std::mutex> _ProjectionRead_T1Wait_lock(_ProjectionRead_T1Wait_mutex); - _OpCache_with_parameter_T1Wait.insert({readState, writeState}); - } - } + CAN_BUS_tlc copiedState = state._copy(); + CAN_BUS_tlc::_ProjectionRead_T1Wait readState = state._projected_state_for_T1Wait(); + + auto _OpCache_with_parameter_T1Wait_ptr = _OpCache_T1Wait.find(param); + if(_OpCache_with_parameter_T1Wait_ptr == _OpCache_T1Wait.end()) { + copiedState.T1Wait(_tmp_1); + CAN_BUS_tlc::_ProjectionWrite_T1Wait writeState = copiedState._update_for_T1Wait(); + std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T1Wait, CAN_BUS_tlc::_ProjectionWrite_T1Wait, CAN_BUS_tlc::_ProjectionRead_T1Wait::Hash, CAN_BUS_tlc::_ProjectionRead_T1Wait::HashEqual> _OpCache_with_parameter_T1Wait; + _OpCache_with_parameter_T1Wait.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_T1Wait_lock(_ProjectionRead_T1Wait_mutex); + _OpCache_T1Wait.insert({param, _OpCache_with_parameter_T1Wait}); } - copiedState.stateAccessedVia = "T1Wait"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<BInteger> _trid_4 = _trid_4_ptr->second; - for(const BInteger& param : _trid_4) { - BInteger _tmp_1 = param; - - CAN_BUS_tlc copiedState = state._copy(); - CAN_BUS_tlc::_ProjectionRead_T1Wait readState = state._projected_state_for_T1Wait(); - - auto _OpCache_with_parameter_T1Wait_ptr = _OpCache_T1Wait.find(param); - if(_OpCache_with_parameter_T1Wait_ptr == _OpCache_T1Wait.end()) { + } else { + std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T1Wait, CAN_BUS_tlc::_ProjectionWrite_T1Wait, CAN_BUS_tlc::_ProjectionRead_T1Wait::Hash, CAN_BUS_tlc::_ProjectionRead_T1Wait::HashEqual> _OpCache_with_parameter_T1Wait = _OpCache_with_parameter_T1Wait_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_T1Wait.find(readState); + if(writeState_ptr != _OpCache_with_parameter_T1Wait.end()) { + CAN_BUS_tlc::_ProjectionWrite_T1Wait writeState = writeState_ptr->second; + copiedState._apply_update_for_T1Wait(writeState); + } else { copiedState.T1Wait(_tmp_1); CAN_BUS_tlc::_ProjectionWrite_T1Wait writeState = copiedState._update_for_T1Wait(); - std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T1Wait, CAN_BUS_tlc::_ProjectionWrite_T1Wait, CAN_BUS_tlc::_ProjectionRead_T1Wait::Hash, CAN_BUS_tlc::_ProjectionRead_T1Wait::HashEqual> _OpCache_with_parameter_T1Wait; - _OpCache_with_parameter_T1Wait.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_T1Wait_lock(_ProjectionRead_T1Wait_mutex); - _OpCache_T1Wait.insert({param, _OpCache_with_parameter_T1Wait}); - } - - } else { - std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T1Wait, CAN_BUS_tlc::_ProjectionWrite_T1Wait, CAN_BUS_tlc::_ProjectionRead_T1Wait::Hash, CAN_BUS_tlc::_ProjectionRead_T1Wait::HashEqual> _OpCache_with_parameter_T1Wait = _OpCache_with_parameter_T1Wait_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_T1Wait.find(readState); - if(writeState_ptr != _OpCache_with_parameter_T1Wait.end()) { - CAN_BUS_tlc::_ProjectionWrite_T1Wait writeState = writeState_ptr->second; - copiedState._apply_update_for_T1Wait(writeState); - } else { - copiedState.T1Wait(_tmp_1); - CAN_BUS_tlc::_ProjectionWrite_T1Wait writeState = copiedState._update_for_T1Wait(); - { - std::unique_lock<std::mutex> _ProjectionRead_T1Wait_lock(_ProjectionRead_T1Wait_mutex); - _OpCache_with_parameter_T1Wait.insert({readState, writeState}); - } + _OpCache_with_parameter_T1Wait.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "T1Wait"; - result.insert(copiedState); + copiedState.stateAccessedVia = "T1Wait"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } @@ -6552,92 +6466,62 @@ class ModelChecker { copiedState.stateAccessedVia = "T2Evaluate"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } CAN_BUS_tlc::_ProjectionRead__tr_T2ReadBus read__tr_T2ReadBus_state = state._projected_state_for__tr_T2ReadBus(); + BSet<BTuple<BInteger, BInteger >> _trid_6; auto _trid_6_ptr = _OpCache_tr_T2ReadBus.find(read__tr_T2ReadBus_state); if(_trid_6_ptr == _OpCache_tr_T2ReadBus.end()) { - BSet<BTuple<BInteger, BInteger >> _trid_6 = state._tr_T2ReadBus(); + _trid_6 = state._tr_T2ReadBus(); { std::unique_lock<std::mutex> _ProjectionRead__tr_T2ReadBus_lock(_ProjectionRead__tr_T2ReadBus_mutex); _OpCache_tr_T2ReadBus.insert({read__tr_T2ReadBus_state, _trid_6}); } - for(const BTuple<BInteger, BInteger >& param : _trid_6) { - BInteger _tmp_1 = param.projection2(); - BInteger _tmp_2 = param.projection1(); - - CAN_BUS_tlc copiedState = state._copy(); - CAN_BUS_tlc::_ProjectionRead_T2ReadBus readState = state._projected_state_for_T2ReadBus(); + } else { + _trid_6 = _trid_6_ptr->second; + } - auto _OpCache_with_parameter_T2ReadBus_ptr = _OpCache_T2ReadBus.find(param); - if(_OpCache_with_parameter_T2ReadBus_ptr == _OpCache_T2ReadBus.end()) { - copiedState.T2ReadBus(_tmp_2, _tmp_1); - CAN_BUS_tlc::_ProjectionWrite_T2ReadBus writeState = copiedState._update_for_T2ReadBus(); - std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T2ReadBus, CAN_BUS_tlc::_ProjectionWrite_T2ReadBus, CAN_BUS_tlc::_ProjectionRead_T2ReadBus::Hash, CAN_BUS_tlc::_ProjectionRead_T2ReadBus::HashEqual> _OpCache_with_parameter_T2ReadBus; - _OpCache_with_parameter_T2ReadBus.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_T2ReadBus_lock(_ProjectionRead_T2ReadBus_mutex); - _OpCache_T2ReadBus.insert({param, _OpCache_with_parameter_T2ReadBus}); - } + for(const BTuple<BInteger, BInteger >& param : _trid_6) { + BInteger _tmp_1 = param.projection2(); + BInteger _tmp_2 = param.projection1(); - } else { - std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T2ReadBus, CAN_BUS_tlc::_ProjectionWrite_T2ReadBus, CAN_BUS_tlc::_ProjectionRead_T2ReadBus::Hash, CAN_BUS_tlc::_ProjectionRead_T2ReadBus::HashEqual> _OpCache_with_parameter_T2ReadBus = _OpCache_with_parameter_T2ReadBus_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_T2ReadBus.find(readState); - if(writeState_ptr != _OpCache_with_parameter_T2ReadBus.end()) { - CAN_BUS_tlc::_ProjectionWrite_T2ReadBus writeState = writeState_ptr->second; - copiedState._apply_update_for_T2ReadBus(writeState); - } else { - copiedState.T2ReadBus(_tmp_2, _tmp_1); - CAN_BUS_tlc::_ProjectionWrite_T2ReadBus writeState = copiedState._update_for_T2ReadBus(); - { - std::unique_lock<std::mutex> _ProjectionRead_T2ReadBus_lock(_ProjectionRead_T2ReadBus_mutex); - _OpCache_with_parameter_T2ReadBus.insert({readState, writeState}); - } - } + CAN_BUS_tlc copiedState = state._copy(); + CAN_BUS_tlc::_ProjectionRead_T2ReadBus readState = state._projected_state_for_T2ReadBus(); + + auto _OpCache_with_parameter_T2ReadBus_ptr = _OpCache_T2ReadBus.find(param); + if(_OpCache_with_parameter_T2ReadBus_ptr == _OpCache_T2ReadBus.end()) { + copiedState.T2ReadBus(_tmp_2, _tmp_1); + CAN_BUS_tlc::_ProjectionWrite_T2ReadBus writeState = copiedState._update_for_T2ReadBus(); + std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T2ReadBus, CAN_BUS_tlc::_ProjectionWrite_T2ReadBus, CAN_BUS_tlc::_ProjectionRead_T2ReadBus::Hash, CAN_BUS_tlc::_ProjectionRead_T2ReadBus::HashEqual> _OpCache_with_parameter_T2ReadBus; + _OpCache_with_parameter_T2ReadBus.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_T2ReadBus_lock(_ProjectionRead_T2ReadBus_mutex); + _OpCache_T2ReadBus.insert({param, _OpCache_with_parameter_T2ReadBus}); } - copiedState.stateAccessedVia = "T2ReadBus"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<BTuple<BInteger, BInteger >> _trid_6 = _trid_6_ptr->second; - for(const BTuple<BInteger, BInteger >& param : _trid_6) { - BInteger _tmp_1 = param.projection2(); - BInteger _tmp_2 = param.projection1(); - - CAN_BUS_tlc copiedState = state._copy(); - CAN_BUS_tlc::_ProjectionRead_T2ReadBus readState = state._projected_state_for_T2ReadBus(); - - auto _OpCache_with_parameter_T2ReadBus_ptr = _OpCache_T2ReadBus.find(param); - if(_OpCache_with_parameter_T2ReadBus_ptr == _OpCache_T2ReadBus.end()) { + } else { + std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T2ReadBus, CAN_BUS_tlc::_ProjectionWrite_T2ReadBus, CAN_BUS_tlc::_ProjectionRead_T2ReadBus::Hash, CAN_BUS_tlc::_ProjectionRead_T2ReadBus::HashEqual> _OpCache_with_parameter_T2ReadBus = _OpCache_with_parameter_T2ReadBus_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_T2ReadBus.find(readState); + if(writeState_ptr != _OpCache_with_parameter_T2ReadBus.end()) { + CAN_BUS_tlc::_ProjectionWrite_T2ReadBus writeState = writeState_ptr->second; + copiedState._apply_update_for_T2ReadBus(writeState); + } else { copiedState.T2ReadBus(_tmp_2, _tmp_1); CAN_BUS_tlc::_ProjectionWrite_T2ReadBus writeState = copiedState._update_for_T2ReadBus(); - std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T2ReadBus, CAN_BUS_tlc::_ProjectionWrite_T2ReadBus, CAN_BUS_tlc::_ProjectionRead_T2ReadBus::Hash, CAN_BUS_tlc::_ProjectionRead_T2ReadBus::HashEqual> _OpCache_with_parameter_T2ReadBus; - _OpCache_with_parameter_T2ReadBus.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_T2ReadBus_lock(_ProjectionRead_T2ReadBus_mutex); - _OpCache_T2ReadBus.insert({param, _OpCache_with_parameter_T2ReadBus}); - } - - } else { - std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T2ReadBus, CAN_BUS_tlc::_ProjectionWrite_T2ReadBus, CAN_BUS_tlc::_ProjectionRead_T2ReadBus::Hash, CAN_BUS_tlc::_ProjectionRead_T2ReadBus::HashEqual> _OpCache_with_parameter_T2ReadBus = _OpCache_with_parameter_T2ReadBus_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_T2ReadBus.find(readState); - if(writeState_ptr != _OpCache_with_parameter_T2ReadBus.end()) { - CAN_BUS_tlc::_ProjectionWrite_T2ReadBus writeState = writeState_ptr->second; - copiedState._apply_update_for_T2ReadBus(writeState); - } else { - copiedState.T2ReadBus(_tmp_2, _tmp_1); - CAN_BUS_tlc::_ProjectionWrite_T2ReadBus writeState = copiedState._update_for_T2ReadBus(); - { - std::unique_lock<std::mutex> _ProjectionRead_T2ReadBus_lock(_ProjectionRead_T2ReadBus_mutex); - _OpCache_with_parameter_T2ReadBus.insert({readState, writeState}); - } + _OpCache_with_parameter_T2ReadBus.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "T2ReadBus"; - result.insert(copiedState); + copiedState.stateAccessedVia = "T2ReadBus"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } @@ -6686,7 +6570,10 @@ class ModelChecker { copiedState.stateAccessedVia = "T2Reset"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } CAN_BUS_tlc::_ProjectionRead__tr_T2Complete read__tr_T2Complete_state = state._projected_state_for__tr_T2Complete(); bool _trid_8; @@ -6733,90 +6620,61 @@ class ModelChecker { copiedState.stateAccessedVia = "T2Complete"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } CAN_BUS_tlc::_ProjectionRead__tr_T2ReleaseBus read__tr_T2ReleaseBus_state = state._projected_state_for__tr_T2ReleaseBus(); + BSet<BInteger> _trid_9; auto _trid_9_ptr = _OpCache_tr_T2ReleaseBus.find(read__tr_T2ReleaseBus_state); if(_trid_9_ptr == _OpCache_tr_T2ReleaseBus.end()) { - BSet<BInteger> _trid_9 = state._tr_T2ReleaseBus(); + _trid_9 = state._tr_T2ReleaseBus(); { std::unique_lock<std::mutex> _ProjectionRead__tr_T2ReleaseBus_lock(_ProjectionRead__tr_T2ReleaseBus_mutex); _OpCache_tr_T2ReleaseBus.insert({read__tr_T2ReleaseBus_state, _trid_9}); } - for(const BInteger& param : _trid_9) { - BInteger _tmp_1 = param; - - CAN_BUS_tlc copiedState = state._copy(); - CAN_BUS_tlc::_ProjectionRead_T2ReleaseBus readState = state._projected_state_for_T2ReleaseBus(); + } else { + _trid_9 = _trid_9_ptr->second; + } - auto _OpCache_with_parameter_T2ReleaseBus_ptr = _OpCache_T2ReleaseBus.find(param); - if(_OpCache_with_parameter_T2ReleaseBus_ptr == _OpCache_T2ReleaseBus.end()) { - copiedState.T2ReleaseBus(_tmp_1); - CAN_BUS_tlc::_ProjectionWrite_T2ReleaseBus writeState = copiedState._update_for_T2ReleaseBus(); - std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T2ReleaseBus, CAN_BUS_tlc::_ProjectionWrite_T2ReleaseBus, CAN_BUS_tlc::_ProjectionRead_T2ReleaseBus::Hash, CAN_BUS_tlc::_ProjectionRead_T2ReleaseBus::HashEqual> _OpCache_with_parameter_T2ReleaseBus; - _OpCache_with_parameter_T2ReleaseBus.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_T2ReleaseBus_lock(_ProjectionRead_T2ReleaseBus_mutex); - _OpCache_T2ReleaseBus.insert({param, _OpCache_with_parameter_T2ReleaseBus}); - } + for(const BInteger& param : _trid_9) { + BInteger _tmp_1 = param; - } else { - std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T2ReleaseBus, CAN_BUS_tlc::_ProjectionWrite_T2ReleaseBus, CAN_BUS_tlc::_ProjectionRead_T2ReleaseBus::Hash, CAN_BUS_tlc::_ProjectionRead_T2ReleaseBus::HashEqual> _OpCache_with_parameter_T2ReleaseBus = _OpCache_with_parameter_T2ReleaseBus_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_T2ReleaseBus.find(readState); - if(writeState_ptr != _OpCache_with_parameter_T2ReleaseBus.end()) { - CAN_BUS_tlc::_ProjectionWrite_T2ReleaseBus writeState = writeState_ptr->second; - copiedState._apply_update_for_T2ReleaseBus(writeState); - } else { - copiedState.T2ReleaseBus(_tmp_1); - CAN_BUS_tlc::_ProjectionWrite_T2ReleaseBus writeState = copiedState._update_for_T2ReleaseBus(); - { - std::unique_lock<std::mutex> _ProjectionRead_T2ReleaseBus_lock(_ProjectionRead_T2ReleaseBus_mutex); - _OpCache_with_parameter_T2ReleaseBus.insert({readState, writeState}); - } - } + CAN_BUS_tlc copiedState = state._copy(); + CAN_BUS_tlc::_ProjectionRead_T2ReleaseBus readState = state._projected_state_for_T2ReleaseBus(); + + auto _OpCache_with_parameter_T2ReleaseBus_ptr = _OpCache_T2ReleaseBus.find(param); + if(_OpCache_with_parameter_T2ReleaseBus_ptr == _OpCache_T2ReleaseBus.end()) { + copiedState.T2ReleaseBus(_tmp_1); + CAN_BUS_tlc::_ProjectionWrite_T2ReleaseBus writeState = copiedState._update_for_T2ReleaseBus(); + std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T2ReleaseBus, CAN_BUS_tlc::_ProjectionWrite_T2ReleaseBus, CAN_BUS_tlc::_ProjectionRead_T2ReleaseBus::Hash, CAN_BUS_tlc::_ProjectionRead_T2ReleaseBus::HashEqual> _OpCache_with_parameter_T2ReleaseBus; + _OpCache_with_parameter_T2ReleaseBus.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_T2ReleaseBus_lock(_ProjectionRead_T2ReleaseBus_mutex); + _OpCache_T2ReleaseBus.insert({param, _OpCache_with_parameter_T2ReleaseBus}); } - copiedState.stateAccessedVia = "T2ReleaseBus"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<BInteger> _trid_9 = _trid_9_ptr->second; - for(const BInteger& param : _trid_9) { - BInteger _tmp_1 = param; - - CAN_BUS_tlc copiedState = state._copy(); - CAN_BUS_tlc::_ProjectionRead_T2ReleaseBus readState = state._projected_state_for_T2ReleaseBus(); - - auto _OpCache_with_parameter_T2ReleaseBus_ptr = _OpCache_T2ReleaseBus.find(param); - if(_OpCache_with_parameter_T2ReleaseBus_ptr == _OpCache_T2ReleaseBus.end()) { + } else { + std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T2ReleaseBus, CAN_BUS_tlc::_ProjectionWrite_T2ReleaseBus, CAN_BUS_tlc::_ProjectionRead_T2ReleaseBus::Hash, CAN_BUS_tlc::_ProjectionRead_T2ReleaseBus::HashEqual> _OpCache_with_parameter_T2ReleaseBus = _OpCache_with_parameter_T2ReleaseBus_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_T2ReleaseBus.find(readState); + if(writeState_ptr != _OpCache_with_parameter_T2ReleaseBus.end()) { + CAN_BUS_tlc::_ProjectionWrite_T2ReleaseBus writeState = writeState_ptr->second; + copiedState._apply_update_for_T2ReleaseBus(writeState); + } else { copiedState.T2ReleaseBus(_tmp_1); CAN_BUS_tlc::_ProjectionWrite_T2ReleaseBus writeState = copiedState._update_for_T2ReleaseBus(); - std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T2ReleaseBus, CAN_BUS_tlc::_ProjectionWrite_T2ReleaseBus, CAN_BUS_tlc::_ProjectionRead_T2ReleaseBus::Hash, CAN_BUS_tlc::_ProjectionRead_T2ReleaseBus::HashEqual> _OpCache_with_parameter_T2ReleaseBus; - _OpCache_with_parameter_T2ReleaseBus.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_T2ReleaseBus_lock(_ProjectionRead_T2ReleaseBus_mutex); - _OpCache_T2ReleaseBus.insert({param, _OpCache_with_parameter_T2ReleaseBus}); - } - - } else { - std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T2ReleaseBus, CAN_BUS_tlc::_ProjectionWrite_T2ReleaseBus, CAN_BUS_tlc::_ProjectionRead_T2ReleaseBus::Hash, CAN_BUS_tlc::_ProjectionRead_T2ReleaseBus::HashEqual> _OpCache_with_parameter_T2ReleaseBus = _OpCache_with_parameter_T2ReleaseBus_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_T2ReleaseBus.find(readState); - if(writeState_ptr != _OpCache_with_parameter_T2ReleaseBus.end()) { - CAN_BUS_tlc::_ProjectionWrite_T2ReleaseBus writeState = writeState_ptr->second; - copiedState._apply_update_for_T2ReleaseBus(writeState); - } else { - copiedState.T2ReleaseBus(_tmp_1); - CAN_BUS_tlc::_ProjectionWrite_T2ReleaseBus writeState = copiedState._update_for_T2ReleaseBus(); - { - std::unique_lock<std::mutex> _ProjectionRead_T2ReleaseBus_lock(_ProjectionRead_T2ReleaseBus_mutex); - _OpCache_with_parameter_T2ReleaseBus.insert({readState, writeState}); - } + _OpCache_with_parameter_T2ReleaseBus.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "T2ReleaseBus"; - result.insert(copiedState); + copiedState.stateAccessedVia = "T2ReleaseBus"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } @@ -6865,177 +6723,115 @@ class ModelChecker { copiedState.stateAccessedVia = "T2Calculate"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } CAN_BUS_tlc::_ProjectionRead__tr_T2WriteBus read__tr_T2WriteBus_state = state._projected_state_for__tr_T2WriteBus(); + BSet<BTuple<BInteger, BInteger >> _trid_11; auto _trid_11_ptr = _OpCache_tr_T2WriteBus.find(read__tr_T2WriteBus_state); if(_trid_11_ptr == _OpCache_tr_T2WriteBus.end()) { - BSet<BTuple<BInteger, BInteger >> _trid_11 = state._tr_T2WriteBus(); + _trid_11 = state._tr_T2WriteBus(); { std::unique_lock<std::mutex> _ProjectionRead__tr_T2WriteBus_lock(_ProjectionRead__tr_T2WriteBus_mutex); _OpCache_tr_T2WriteBus.insert({read__tr_T2WriteBus_state, _trid_11}); } - for(const BTuple<BInteger, BInteger >& param : _trid_11) { - BInteger _tmp_1 = param.projection2(); - BInteger _tmp_2 = param.projection1(); - - CAN_BUS_tlc copiedState = state._copy(); - CAN_BUS_tlc::_ProjectionRead_T2WriteBus readState = state._projected_state_for_T2WriteBus(); + } else { + _trid_11 = _trid_11_ptr->second; + } - auto _OpCache_with_parameter_T2WriteBus_ptr = _OpCache_T2WriteBus.find(param); - if(_OpCache_with_parameter_T2WriteBus_ptr == _OpCache_T2WriteBus.end()) { - copiedState.T2WriteBus(_tmp_2, _tmp_1); - CAN_BUS_tlc::_ProjectionWrite_T2WriteBus writeState = copiedState._update_for_T2WriteBus(); - std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T2WriteBus, CAN_BUS_tlc::_ProjectionWrite_T2WriteBus, CAN_BUS_tlc::_ProjectionRead_T2WriteBus::Hash, CAN_BUS_tlc::_ProjectionRead_T2WriteBus::HashEqual> _OpCache_with_parameter_T2WriteBus; - _OpCache_with_parameter_T2WriteBus.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_T2WriteBus_lock(_ProjectionRead_T2WriteBus_mutex); - _OpCache_T2WriteBus.insert({param, _OpCache_with_parameter_T2WriteBus}); - } + for(const BTuple<BInteger, BInteger >& param : _trid_11) { + BInteger _tmp_1 = param.projection2(); + BInteger _tmp_2 = param.projection1(); - } else { - std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T2WriteBus, CAN_BUS_tlc::_ProjectionWrite_T2WriteBus, CAN_BUS_tlc::_ProjectionRead_T2WriteBus::Hash, CAN_BUS_tlc::_ProjectionRead_T2WriteBus::HashEqual> _OpCache_with_parameter_T2WriteBus = _OpCache_with_parameter_T2WriteBus_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_T2WriteBus.find(readState); - if(writeState_ptr != _OpCache_with_parameter_T2WriteBus.end()) { - CAN_BUS_tlc::_ProjectionWrite_T2WriteBus writeState = writeState_ptr->second; - copiedState._apply_update_for_T2WriteBus(writeState); - } else { - copiedState.T2WriteBus(_tmp_2, _tmp_1); - CAN_BUS_tlc::_ProjectionWrite_T2WriteBus writeState = copiedState._update_for_T2WriteBus(); - { - std::unique_lock<std::mutex> _ProjectionRead_T2WriteBus_lock(_ProjectionRead_T2WriteBus_mutex); - _OpCache_with_parameter_T2WriteBus.insert({readState, writeState}); - } - } + CAN_BUS_tlc copiedState = state._copy(); + CAN_BUS_tlc::_ProjectionRead_T2WriteBus readState = state._projected_state_for_T2WriteBus(); + + auto _OpCache_with_parameter_T2WriteBus_ptr = _OpCache_T2WriteBus.find(param); + if(_OpCache_with_parameter_T2WriteBus_ptr == _OpCache_T2WriteBus.end()) { + copiedState.T2WriteBus(_tmp_2, _tmp_1); + CAN_BUS_tlc::_ProjectionWrite_T2WriteBus writeState = copiedState._update_for_T2WriteBus(); + std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T2WriteBus, CAN_BUS_tlc::_ProjectionWrite_T2WriteBus, CAN_BUS_tlc::_ProjectionRead_T2WriteBus::Hash, CAN_BUS_tlc::_ProjectionRead_T2WriteBus::HashEqual> _OpCache_with_parameter_T2WriteBus; + _OpCache_with_parameter_T2WriteBus.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_T2WriteBus_lock(_ProjectionRead_T2WriteBus_mutex); + _OpCache_T2WriteBus.insert({param, _OpCache_with_parameter_T2WriteBus}); } - copiedState.stateAccessedVia = "T2WriteBus"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<BTuple<BInteger, BInteger >> _trid_11 = _trid_11_ptr->second; - for(const BTuple<BInteger, BInteger >& param : _trid_11) { - BInteger _tmp_1 = param.projection2(); - BInteger _tmp_2 = param.projection1(); - - CAN_BUS_tlc copiedState = state._copy(); - CAN_BUS_tlc::_ProjectionRead_T2WriteBus readState = state._projected_state_for_T2WriteBus(); - - auto _OpCache_with_parameter_T2WriteBus_ptr = _OpCache_T2WriteBus.find(param); - if(_OpCache_with_parameter_T2WriteBus_ptr == _OpCache_T2WriteBus.end()) { + } else { + std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T2WriteBus, CAN_BUS_tlc::_ProjectionWrite_T2WriteBus, CAN_BUS_tlc::_ProjectionRead_T2WriteBus::Hash, CAN_BUS_tlc::_ProjectionRead_T2WriteBus::HashEqual> _OpCache_with_parameter_T2WriteBus = _OpCache_with_parameter_T2WriteBus_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_T2WriteBus.find(readState); + if(writeState_ptr != _OpCache_with_parameter_T2WriteBus.end()) { + CAN_BUS_tlc::_ProjectionWrite_T2WriteBus writeState = writeState_ptr->second; + copiedState._apply_update_for_T2WriteBus(writeState); + } else { copiedState.T2WriteBus(_tmp_2, _tmp_1); CAN_BUS_tlc::_ProjectionWrite_T2WriteBus writeState = copiedState._update_for_T2WriteBus(); - std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T2WriteBus, CAN_BUS_tlc::_ProjectionWrite_T2WriteBus, CAN_BUS_tlc::_ProjectionRead_T2WriteBus::Hash, CAN_BUS_tlc::_ProjectionRead_T2WriteBus::HashEqual> _OpCache_with_parameter_T2WriteBus; - _OpCache_with_parameter_T2WriteBus.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_T2WriteBus_lock(_ProjectionRead_T2WriteBus_mutex); - _OpCache_T2WriteBus.insert({param, _OpCache_with_parameter_T2WriteBus}); - } - - } else { - std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T2WriteBus, CAN_BUS_tlc::_ProjectionWrite_T2WriteBus, CAN_BUS_tlc::_ProjectionRead_T2WriteBus::Hash, CAN_BUS_tlc::_ProjectionRead_T2WriteBus::HashEqual> _OpCache_with_parameter_T2WriteBus = _OpCache_with_parameter_T2WriteBus_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_T2WriteBus.find(readState); - if(writeState_ptr != _OpCache_with_parameter_T2WriteBus.end()) { - CAN_BUS_tlc::_ProjectionWrite_T2WriteBus writeState = writeState_ptr->second; - copiedState._apply_update_for_T2WriteBus(writeState); - } else { - copiedState.T2WriteBus(_tmp_2, _tmp_1); - CAN_BUS_tlc::_ProjectionWrite_T2WriteBus writeState = copiedState._update_for_T2WriteBus(); - { - std::unique_lock<std::mutex> _ProjectionRead_T2WriteBus_lock(_ProjectionRead_T2WriteBus_mutex); - _OpCache_with_parameter_T2WriteBus.insert({readState, writeState}); - } + _OpCache_with_parameter_T2WriteBus.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "T2WriteBus"; - result.insert(copiedState); + copiedState.stateAccessedVia = "T2WriteBus"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } CAN_BUS_tlc::_ProjectionRead__tr_T2Wait read__tr_T2Wait_state = state._projected_state_for__tr_T2Wait(); + BSet<BInteger> _trid_12; auto _trid_12_ptr = _OpCache_tr_T2Wait.find(read__tr_T2Wait_state); if(_trid_12_ptr == _OpCache_tr_T2Wait.end()) { - BSet<BInteger> _trid_12 = state._tr_T2Wait(); + _trid_12 = state._tr_T2Wait(); { std::unique_lock<std::mutex> _ProjectionRead__tr_T2Wait_lock(_ProjectionRead__tr_T2Wait_mutex); _OpCache_tr_T2Wait.insert({read__tr_T2Wait_state, _trid_12}); } - for(const BInteger& param : _trid_12) { - BInteger _tmp_1 = param; - - CAN_BUS_tlc copiedState = state._copy(); - CAN_BUS_tlc::_ProjectionRead_T2Wait readState = state._projected_state_for_T2Wait(); + } else { + _trid_12 = _trid_12_ptr->second; + } - auto _OpCache_with_parameter_T2Wait_ptr = _OpCache_T2Wait.find(param); - if(_OpCache_with_parameter_T2Wait_ptr == _OpCache_T2Wait.end()) { - copiedState.T2Wait(_tmp_1); - CAN_BUS_tlc::_ProjectionWrite_T2Wait writeState = copiedState._update_for_T2Wait(); - std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T2Wait, CAN_BUS_tlc::_ProjectionWrite_T2Wait, CAN_BUS_tlc::_ProjectionRead_T2Wait::Hash, CAN_BUS_tlc::_ProjectionRead_T2Wait::HashEqual> _OpCache_with_parameter_T2Wait; - _OpCache_with_parameter_T2Wait.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_T2Wait_lock(_ProjectionRead_T2Wait_mutex); - _OpCache_T2Wait.insert({param, _OpCache_with_parameter_T2Wait}); - } + for(const BInteger& param : _trid_12) { + BInteger _tmp_1 = param; - } else { - std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T2Wait, CAN_BUS_tlc::_ProjectionWrite_T2Wait, CAN_BUS_tlc::_ProjectionRead_T2Wait::Hash, CAN_BUS_tlc::_ProjectionRead_T2Wait::HashEqual> _OpCache_with_parameter_T2Wait = _OpCache_with_parameter_T2Wait_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_T2Wait.find(readState); - if(writeState_ptr != _OpCache_with_parameter_T2Wait.end()) { - CAN_BUS_tlc::_ProjectionWrite_T2Wait writeState = writeState_ptr->second; - copiedState._apply_update_for_T2Wait(writeState); - } else { - copiedState.T2Wait(_tmp_1); - CAN_BUS_tlc::_ProjectionWrite_T2Wait writeState = copiedState._update_for_T2Wait(); - { - std::unique_lock<std::mutex> _ProjectionRead_T2Wait_lock(_ProjectionRead_T2Wait_mutex); - _OpCache_with_parameter_T2Wait.insert({readState, writeState}); - } - } + CAN_BUS_tlc copiedState = state._copy(); + CAN_BUS_tlc::_ProjectionRead_T2Wait readState = state._projected_state_for_T2Wait(); + + auto _OpCache_with_parameter_T2Wait_ptr = _OpCache_T2Wait.find(param); + if(_OpCache_with_parameter_T2Wait_ptr == _OpCache_T2Wait.end()) { + copiedState.T2Wait(_tmp_1); + CAN_BUS_tlc::_ProjectionWrite_T2Wait writeState = copiedState._update_for_T2Wait(); + std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T2Wait, CAN_BUS_tlc::_ProjectionWrite_T2Wait, CAN_BUS_tlc::_ProjectionRead_T2Wait::Hash, CAN_BUS_tlc::_ProjectionRead_T2Wait::HashEqual> _OpCache_with_parameter_T2Wait; + _OpCache_with_parameter_T2Wait.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_T2Wait_lock(_ProjectionRead_T2Wait_mutex); + _OpCache_T2Wait.insert({param, _OpCache_with_parameter_T2Wait}); } - copiedState.stateAccessedVia = "T2Wait"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<BInteger> _trid_12 = _trid_12_ptr->second; - for(const BInteger& param : _trid_12) { - BInteger _tmp_1 = param; - - CAN_BUS_tlc copiedState = state._copy(); - CAN_BUS_tlc::_ProjectionRead_T2Wait readState = state._projected_state_for_T2Wait(); - - auto _OpCache_with_parameter_T2Wait_ptr = _OpCache_T2Wait.find(param); - if(_OpCache_with_parameter_T2Wait_ptr == _OpCache_T2Wait.end()) { + } else { + std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T2Wait, CAN_BUS_tlc::_ProjectionWrite_T2Wait, CAN_BUS_tlc::_ProjectionRead_T2Wait::Hash, CAN_BUS_tlc::_ProjectionRead_T2Wait::HashEqual> _OpCache_with_parameter_T2Wait = _OpCache_with_parameter_T2Wait_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_T2Wait.find(readState); + if(writeState_ptr != _OpCache_with_parameter_T2Wait.end()) { + CAN_BUS_tlc::_ProjectionWrite_T2Wait writeState = writeState_ptr->second; + copiedState._apply_update_for_T2Wait(writeState); + } else { copiedState.T2Wait(_tmp_1); CAN_BUS_tlc::_ProjectionWrite_T2Wait writeState = copiedState._update_for_T2Wait(); - std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T2Wait, CAN_BUS_tlc::_ProjectionWrite_T2Wait, CAN_BUS_tlc::_ProjectionRead_T2Wait::Hash, CAN_BUS_tlc::_ProjectionRead_T2Wait::HashEqual> _OpCache_with_parameter_T2Wait; - _OpCache_with_parameter_T2Wait.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_T2Wait_lock(_ProjectionRead_T2Wait_mutex); - _OpCache_T2Wait.insert({param, _OpCache_with_parameter_T2Wait}); - } - - } else { - std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T2Wait, CAN_BUS_tlc::_ProjectionWrite_T2Wait, CAN_BUS_tlc::_ProjectionRead_T2Wait::Hash, CAN_BUS_tlc::_ProjectionRead_T2Wait::HashEqual> _OpCache_with_parameter_T2Wait = _OpCache_with_parameter_T2Wait_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_T2Wait.find(readState); - if(writeState_ptr != _OpCache_with_parameter_T2Wait.end()) { - CAN_BUS_tlc::_ProjectionWrite_T2Wait writeState = writeState_ptr->second; - copiedState._apply_update_for_T2Wait(writeState); - } else { - copiedState.T2Wait(_tmp_1); - CAN_BUS_tlc::_ProjectionWrite_T2Wait writeState = copiedState._update_for_T2Wait(); - { - std::unique_lock<std::mutex> _ProjectionRead_T2Wait_lock(_ProjectionRead_T2Wait_mutex); - _OpCache_with_parameter_T2Wait.insert({readState, writeState}); - } + _OpCache_with_parameter_T2Wait.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "T2Wait"; - result.insert(copiedState); + copiedState.stateAccessedVia = "T2Wait"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } @@ -7084,7 +6880,10 @@ class ModelChecker { copiedState.stateAccessedVia = "T3Initiate"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } CAN_BUS_tlc::_ProjectionRead__tr_T3Evaluate read__tr_T3Evaluate_state = state._projected_state_for__tr_T3Evaluate(); bool _trid_14; @@ -7131,179 +6930,116 @@ class ModelChecker { copiedState.stateAccessedVia = "T3Evaluate"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } CAN_BUS_tlc::_ProjectionRead__tr_T3writebus read__tr_T3writebus_state = state._projected_state_for__tr_T3writebus(); + BSet<BTuple<BInteger, BInteger >> _trid_15; auto _trid_15_ptr = _OpCache_tr_T3writebus.find(read__tr_T3writebus_state); if(_trid_15_ptr == _OpCache_tr_T3writebus.end()) { - BSet<BTuple<BInteger, BInteger >> _trid_15 = state._tr_T3writebus(); + _trid_15 = state._tr_T3writebus(); { std::unique_lock<std::mutex> _ProjectionRead__tr_T3writebus_lock(_ProjectionRead__tr_T3writebus_mutex); _OpCache_tr_T3writebus.insert({read__tr_T3writebus_state, _trid_15}); } - for(const BTuple<BInteger, BInteger >& param : _trid_15) { - BInteger _tmp_1 = param.projection2(); - BInteger _tmp_2 = param.projection1(); - - CAN_BUS_tlc copiedState = state._copy(); - CAN_BUS_tlc::_ProjectionRead_T3writebus readState = state._projected_state_for_T3writebus(); + } else { + _trid_15 = _trid_15_ptr->second; + } - auto _OpCache_with_parameter_T3writebus_ptr = _OpCache_T3writebus.find(param); - if(_OpCache_with_parameter_T3writebus_ptr == _OpCache_T3writebus.end()) { - copiedState.T3writebus(_tmp_2, _tmp_1); - CAN_BUS_tlc::_ProjectionWrite_T3writebus writeState = copiedState._update_for_T3writebus(); - std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T3writebus, CAN_BUS_tlc::_ProjectionWrite_T3writebus, CAN_BUS_tlc::_ProjectionRead_T3writebus::Hash, CAN_BUS_tlc::_ProjectionRead_T3writebus::HashEqual> _OpCache_with_parameter_T3writebus; - _OpCache_with_parameter_T3writebus.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_T3writebus_lock(_ProjectionRead_T3writebus_mutex); - _OpCache_T3writebus.insert({param, _OpCache_with_parameter_T3writebus}); - } + for(const BTuple<BInteger, BInteger >& param : _trid_15) { + BInteger _tmp_1 = param.projection2(); + BInteger _tmp_2 = param.projection1(); - } else { - std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T3writebus, CAN_BUS_tlc::_ProjectionWrite_T3writebus, CAN_BUS_tlc::_ProjectionRead_T3writebus::Hash, CAN_BUS_tlc::_ProjectionRead_T3writebus::HashEqual> _OpCache_with_parameter_T3writebus = _OpCache_with_parameter_T3writebus_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_T3writebus.find(readState); - if(writeState_ptr != _OpCache_with_parameter_T3writebus.end()) { - CAN_BUS_tlc::_ProjectionWrite_T3writebus writeState = writeState_ptr->second; - copiedState._apply_update_for_T3writebus(writeState); - } else { - copiedState.T3writebus(_tmp_2, _tmp_1); - CAN_BUS_tlc::_ProjectionWrite_T3writebus writeState = copiedState._update_for_T3writebus(); - { - std::unique_lock<std::mutex> _ProjectionRead_T3writebus_lock(_ProjectionRead_T3writebus_mutex); - _OpCache_with_parameter_T3writebus.insert({readState, writeState}); - } - } + CAN_BUS_tlc copiedState = state._copy(); + CAN_BUS_tlc::_ProjectionRead_T3writebus readState = state._projected_state_for_T3writebus(); + + auto _OpCache_with_parameter_T3writebus_ptr = _OpCache_T3writebus.find(param); + if(_OpCache_with_parameter_T3writebus_ptr == _OpCache_T3writebus.end()) { + copiedState.T3writebus(_tmp_2, _tmp_1); + CAN_BUS_tlc::_ProjectionWrite_T3writebus writeState = copiedState._update_for_T3writebus(); + std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T3writebus, CAN_BUS_tlc::_ProjectionWrite_T3writebus, CAN_BUS_tlc::_ProjectionRead_T3writebus::Hash, CAN_BUS_tlc::_ProjectionRead_T3writebus::HashEqual> _OpCache_with_parameter_T3writebus; + _OpCache_with_parameter_T3writebus.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_T3writebus_lock(_ProjectionRead_T3writebus_mutex); + _OpCache_T3writebus.insert({param, _OpCache_with_parameter_T3writebus}); } - copiedState.stateAccessedVia = "T3writebus"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<BTuple<BInteger, BInteger >> _trid_15 = _trid_15_ptr->second; - for(const BTuple<BInteger, BInteger >& param : _trid_15) { - BInteger _tmp_1 = param.projection2(); - BInteger _tmp_2 = param.projection1(); - - CAN_BUS_tlc copiedState = state._copy(); - CAN_BUS_tlc::_ProjectionRead_T3writebus readState = state._projected_state_for_T3writebus(); - - auto _OpCache_with_parameter_T3writebus_ptr = _OpCache_T3writebus.find(param); - if(_OpCache_with_parameter_T3writebus_ptr == _OpCache_T3writebus.end()) { + } else { + std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T3writebus, CAN_BUS_tlc::_ProjectionWrite_T3writebus, CAN_BUS_tlc::_ProjectionRead_T3writebus::Hash, CAN_BUS_tlc::_ProjectionRead_T3writebus::HashEqual> _OpCache_with_parameter_T3writebus = _OpCache_with_parameter_T3writebus_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_T3writebus.find(readState); + if(writeState_ptr != _OpCache_with_parameter_T3writebus.end()) { + CAN_BUS_tlc::_ProjectionWrite_T3writebus writeState = writeState_ptr->second; + copiedState._apply_update_for_T3writebus(writeState); + } else { copiedState.T3writebus(_tmp_2, _tmp_1); CAN_BUS_tlc::_ProjectionWrite_T3writebus writeState = copiedState._update_for_T3writebus(); - std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T3writebus, CAN_BUS_tlc::_ProjectionWrite_T3writebus, CAN_BUS_tlc::_ProjectionRead_T3writebus::Hash, CAN_BUS_tlc::_ProjectionRead_T3writebus::HashEqual> _OpCache_with_parameter_T3writebus; - _OpCache_with_parameter_T3writebus.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_T3writebus_lock(_ProjectionRead_T3writebus_mutex); - _OpCache_T3writebus.insert({param, _OpCache_with_parameter_T3writebus}); - } - - } else { - std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T3writebus, CAN_BUS_tlc::_ProjectionWrite_T3writebus, CAN_BUS_tlc::_ProjectionRead_T3writebus::Hash, CAN_BUS_tlc::_ProjectionRead_T3writebus::HashEqual> _OpCache_with_parameter_T3writebus = _OpCache_with_parameter_T3writebus_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_T3writebus.find(readState); - if(writeState_ptr != _OpCache_with_parameter_T3writebus.end()) { - CAN_BUS_tlc::_ProjectionWrite_T3writebus writeState = writeState_ptr->second; - copiedState._apply_update_for_T3writebus(writeState); - } else { - copiedState.T3writebus(_tmp_2, _tmp_1); - CAN_BUS_tlc::_ProjectionWrite_T3writebus writeState = copiedState._update_for_T3writebus(); - { - std::unique_lock<std::mutex> _ProjectionRead_T3writebus_lock(_ProjectionRead_T3writebus_mutex); - _OpCache_with_parameter_T3writebus.insert({readState, writeState}); - } + _OpCache_with_parameter_T3writebus.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "T3writebus"; - result.insert(copiedState); + copiedState.stateAccessedVia = "T3writebus"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } CAN_BUS_tlc::_ProjectionRead__tr_T3Read read__tr_T3Read_state = state._projected_state_for__tr_T3Read(); + BSet<BTuple<BInteger, BInteger >> _trid_16; auto _trid_16_ptr = _OpCache_tr_T3Read.find(read__tr_T3Read_state); if(_trid_16_ptr == _OpCache_tr_T3Read.end()) { - BSet<BTuple<BInteger, BInteger >> _trid_16 = state._tr_T3Read(); + _trid_16 = state._tr_T3Read(); { std::unique_lock<std::mutex> _ProjectionRead__tr_T3Read_lock(_ProjectionRead__tr_T3Read_mutex); _OpCache_tr_T3Read.insert({read__tr_T3Read_state, _trid_16}); } - for(const BTuple<BInteger, BInteger >& param : _trid_16) { - BInteger _tmp_1 = param.projection2(); - BInteger _tmp_2 = param.projection1(); - - CAN_BUS_tlc copiedState = state._copy(); - CAN_BUS_tlc::_ProjectionRead_T3Read readState = state._projected_state_for_T3Read(); + } else { + _trid_16 = _trid_16_ptr->second; + } - auto _OpCache_with_parameter_T3Read_ptr = _OpCache_T3Read.find(param); - if(_OpCache_with_parameter_T3Read_ptr == _OpCache_T3Read.end()) { - copiedState.T3Read(_tmp_2, _tmp_1); - CAN_BUS_tlc::_ProjectionWrite_T3Read writeState = copiedState._update_for_T3Read(); - std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T3Read, CAN_BUS_tlc::_ProjectionWrite_T3Read, CAN_BUS_tlc::_ProjectionRead_T3Read::Hash, CAN_BUS_tlc::_ProjectionRead_T3Read::HashEqual> _OpCache_with_parameter_T3Read; - _OpCache_with_parameter_T3Read.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_T3Read_lock(_ProjectionRead_T3Read_mutex); - _OpCache_T3Read.insert({param, _OpCache_with_parameter_T3Read}); - } + for(const BTuple<BInteger, BInteger >& param : _trid_16) { + BInteger _tmp_1 = param.projection2(); + BInteger _tmp_2 = param.projection1(); - } else { - std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T3Read, CAN_BUS_tlc::_ProjectionWrite_T3Read, CAN_BUS_tlc::_ProjectionRead_T3Read::Hash, CAN_BUS_tlc::_ProjectionRead_T3Read::HashEqual> _OpCache_with_parameter_T3Read = _OpCache_with_parameter_T3Read_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_T3Read.find(readState); - if(writeState_ptr != _OpCache_with_parameter_T3Read.end()) { - CAN_BUS_tlc::_ProjectionWrite_T3Read writeState = writeState_ptr->second; - copiedState._apply_update_for_T3Read(writeState); - } else { - copiedState.T3Read(_tmp_2, _tmp_1); - CAN_BUS_tlc::_ProjectionWrite_T3Read writeState = copiedState._update_for_T3Read(); - { - std::unique_lock<std::mutex> _ProjectionRead_T3Read_lock(_ProjectionRead_T3Read_mutex); - _OpCache_with_parameter_T3Read.insert({readState, writeState}); - } - } + CAN_BUS_tlc copiedState = state._copy(); + CAN_BUS_tlc::_ProjectionRead_T3Read readState = state._projected_state_for_T3Read(); + + auto _OpCache_with_parameter_T3Read_ptr = _OpCache_T3Read.find(param); + if(_OpCache_with_parameter_T3Read_ptr == _OpCache_T3Read.end()) { + copiedState.T3Read(_tmp_2, _tmp_1); + CAN_BUS_tlc::_ProjectionWrite_T3Read writeState = copiedState._update_for_T3Read(); + std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T3Read, CAN_BUS_tlc::_ProjectionWrite_T3Read, CAN_BUS_tlc::_ProjectionRead_T3Read::Hash, CAN_BUS_tlc::_ProjectionRead_T3Read::HashEqual> _OpCache_with_parameter_T3Read; + _OpCache_with_parameter_T3Read.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_T3Read_lock(_ProjectionRead_T3Read_mutex); + _OpCache_T3Read.insert({param, _OpCache_with_parameter_T3Read}); } - copiedState.stateAccessedVia = "T3Read"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<BTuple<BInteger, BInteger >> _trid_16 = _trid_16_ptr->second; - for(const BTuple<BInteger, BInteger >& param : _trid_16) { - BInteger _tmp_1 = param.projection2(); - BInteger _tmp_2 = param.projection1(); - - CAN_BUS_tlc copiedState = state._copy(); - CAN_BUS_tlc::_ProjectionRead_T3Read readState = state._projected_state_for_T3Read(); - - auto _OpCache_with_parameter_T3Read_ptr = _OpCache_T3Read.find(param); - if(_OpCache_with_parameter_T3Read_ptr == _OpCache_T3Read.end()) { + } else { + std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T3Read, CAN_BUS_tlc::_ProjectionWrite_T3Read, CAN_BUS_tlc::_ProjectionRead_T3Read::Hash, CAN_BUS_tlc::_ProjectionRead_T3Read::HashEqual> _OpCache_with_parameter_T3Read = _OpCache_with_parameter_T3Read_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_T3Read.find(readState); + if(writeState_ptr != _OpCache_with_parameter_T3Read.end()) { + CAN_BUS_tlc::_ProjectionWrite_T3Read writeState = writeState_ptr->second; + copiedState._apply_update_for_T3Read(writeState); + } else { copiedState.T3Read(_tmp_2, _tmp_1); CAN_BUS_tlc::_ProjectionWrite_T3Read writeState = copiedState._update_for_T3Read(); - std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T3Read, CAN_BUS_tlc::_ProjectionWrite_T3Read, CAN_BUS_tlc::_ProjectionRead_T3Read::Hash, CAN_BUS_tlc::_ProjectionRead_T3Read::HashEqual> _OpCache_with_parameter_T3Read; - _OpCache_with_parameter_T3Read.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_T3Read_lock(_ProjectionRead_T3Read_mutex); - _OpCache_T3Read.insert({param, _OpCache_with_parameter_T3Read}); - } - - } else { - std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T3Read, CAN_BUS_tlc::_ProjectionWrite_T3Read, CAN_BUS_tlc::_ProjectionRead_T3Read::Hash, CAN_BUS_tlc::_ProjectionRead_T3Read::HashEqual> _OpCache_with_parameter_T3Read = _OpCache_with_parameter_T3Read_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_T3Read.find(readState); - if(writeState_ptr != _OpCache_with_parameter_T3Read.end()) { - CAN_BUS_tlc::_ProjectionWrite_T3Read writeState = writeState_ptr->second; - copiedState._apply_update_for_T3Read(writeState); - } else { - copiedState.T3Read(_tmp_2, _tmp_1); - CAN_BUS_tlc::_ProjectionWrite_T3Read writeState = copiedState._update_for_T3Read(); - { - std::unique_lock<std::mutex> _ProjectionRead_T3Read_lock(_ProjectionRead_T3Read_mutex); - _OpCache_with_parameter_T3Read.insert({readState, writeState}); - } + _OpCache_with_parameter_T3Read.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "T3Read"; - result.insert(copiedState); + copiedState.stateAccessedVia = "T3Read"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } @@ -7352,90 +7088,61 @@ class ModelChecker { copiedState.stateAccessedVia = "T3Poll"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } CAN_BUS_tlc::_ProjectionRead__tr_T3ReleaseBus read__tr_T3ReleaseBus_state = state._projected_state_for__tr_T3ReleaseBus(); + BSet<BInteger> _trid_18; auto _trid_18_ptr = _OpCache_tr_T3ReleaseBus.find(read__tr_T3ReleaseBus_state); if(_trid_18_ptr == _OpCache_tr_T3ReleaseBus.end()) { - BSet<BInteger> _trid_18 = state._tr_T3ReleaseBus(); + _trid_18 = state._tr_T3ReleaseBus(); { std::unique_lock<std::mutex> _ProjectionRead__tr_T3ReleaseBus_lock(_ProjectionRead__tr_T3ReleaseBus_mutex); _OpCache_tr_T3ReleaseBus.insert({read__tr_T3ReleaseBus_state, _trid_18}); } - for(const BInteger& param : _trid_18) { - BInteger _tmp_1 = param; - - CAN_BUS_tlc copiedState = state._copy(); - CAN_BUS_tlc::_ProjectionRead_T3ReleaseBus readState = state._projected_state_for_T3ReleaseBus(); + } else { + _trid_18 = _trid_18_ptr->second; + } - auto _OpCache_with_parameter_T3ReleaseBus_ptr = _OpCache_T3ReleaseBus.find(param); - if(_OpCache_with_parameter_T3ReleaseBus_ptr == _OpCache_T3ReleaseBus.end()) { - copiedState.T3ReleaseBus(_tmp_1); - CAN_BUS_tlc::_ProjectionWrite_T3ReleaseBus writeState = copiedState._update_for_T3ReleaseBus(); - std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T3ReleaseBus, CAN_BUS_tlc::_ProjectionWrite_T3ReleaseBus, CAN_BUS_tlc::_ProjectionRead_T3ReleaseBus::Hash, CAN_BUS_tlc::_ProjectionRead_T3ReleaseBus::HashEqual> _OpCache_with_parameter_T3ReleaseBus; - _OpCache_with_parameter_T3ReleaseBus.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_T3ReleaseBus_lock(_ProjectionRead_T3ReleaseBus_mutex); - _OpCache_T3ReleaseBus.insert({param, _OpCache_with_parameter_T3ReleaseBus}); - } + for(const BInteger& param : _trid_18) { + BInteger _tmp_1 = param; - } else { - std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T3ReleaseBus, CAN_BUS_tlc::_ProjectionWrite_T3ReleaseBus, CAN_BUS_tlc::_ProjectionRead_T3ReleaseBus::Hash, CAN_BUS_tlc::_ProjectionRead_T3ReleaseBus::HashEqual> _OpCache_with_parameter_T3ReleaseBus = _OpCache_with_parameter_T3ReleaseBus_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_T3ReleaseBus.find(readState); - if(writeState_ptr != _OpCache_with_parameter_T3ReleaseBus.end()) { - CAN_BUS_tlc::_ProjectionWrite_T3ReleaseBus writeState = writeState_ptr->second; - copiedState._apply_update_for_T3ReleaseBus(writeState); - } else { - copiedState.T3ReleaseBus(_tmp_1); - CAN_BUS_tlc::_ProjectionWrite_T3ReleaseBus writeState = copiedState._update_for_T3ReleaseBus(); - { - std::unique_lock<std::mutex> _ProjectionRead_T3ReleaseBus_lock(_ProjectionRead_T3ReleaseBus_mutex); - _OpCache_with_parameter_T3ReleaseBus.insert({readState, writeState}); - } - } + CAN_BUS_tlc copiedState = state._copy(); + CAN_BUS_tlc::_ProjectionRead_T3ReleaseBus readState = state._projected_state_for_T3ReleaseBus(); + + auto _OpCache_with_parameter_T3ReleaseBus_ptr = _OpCache_T3ReleaseBus.find(param); + if(_OpCache_with_parameter_T3ReleaseBus_ptr == _OpCache_T3ReleaseBus.end()) { + copiedState.T3ReleaseBus(_tmp_1); + CAN_BUS_tlc::_ProjectionWrite_T3ReleaseBus writeState = copiedState._update_for_T3ReleaseBus(); + std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T3ReleaseBus, CAN_BUS_tlc::_ProjectionWrite_T3ReleaseBus, CAN_BUS_tlc::_ProjectionRead_T3ReleaseBus::Hash, CAN_BUS_tlc::_ProjectionRead_T3ReleaseBus::HashEqual> _OpCache_with_parameter_T3ReleaseBus; + _OpCache_with_parameter_T3ReleaseBus.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_T3ReleaseBus_lock(_ProjectionRead_T3ReleaseBus_mutex); + _OpCache_T3ReleaseBus.insert({param, _OpCache_with_parameter_T3ReleaseBus}); } - copiedState.stateAccessedVia = "T3ReleaseBus"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<BInteger> _trid_18 = _trid_18_ptr->second; - for(const BInteger& param : _trid_18) { - BInteger _tmp_1 = param; - - CAN_BUS_tlc copiedState = state._copy(); - CAN_BUS_tlc::_ProjectionRead_T3ReleaseBus readState = state._projected_state_for_T3ReleaseBus(); - - auto _OpCache_with_parameter_T3ReleaseBus_ptr = _OpCache_T3ReleaseBus.find(param); - if(_OpCache_with_parameter_T3ReleaseBus_ptr == _OpCache_T3ReleaseBus.end()) { + } else { + std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T3ReleaseBus, CAN_BUS_tlc::_ProjectionWrite_T3ReleaseBus, CAN_BUS_tlc::_ProjectionRead_T3ReleaseBus::Hash, CAN_BUS_tlc::_ProjectionRead_T3ReleaseBus::HashEqual> _OpCache_with_parameter_T3ReleaseBus = _OpCache_with_parameter_T3ReleaseBus_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_T3ReleaseBus.find(readState); + if(writeState_ptr != _OpCache_with_parameter_T3ReleaseBus.end()) { + CAN_BUS_tlc::_ProjectionWrite_T3ReleaseBus writeState = writeState_ptr->second; + copiedState._apply_update_for_T3ReleaseBus(writeState); + } else { copiedState.T3ReleaseBus(_tmp_1); CAN_BUS_tlc::_ProjectionWrite_T3ReleaseBus writeState = copiedState._update_for_T3ReleaseBus(); - std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T3ReleaseBus, CAN_BUS_tlc::_ProjectionWrite_T3ReleaseBus, CAN_BUS_tlc::_ProjectionRead_T3ReleaseBus::Hash, CAN_BUS_tlc::_ProjectionRead_T3ReleaseBus::HashEqual> _OpCache_with_parameter_T3ReleaseBus; - _OpCache_with_parameter_T3ReleaseBus.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_T3ReleaseBus_lock(_ProjectionRead_T3ReleaseBus_mutex); - _OpCache_T3ReleaseBus.insert({param, _OpCache_with_parameter_T3ReleaseBus}); - } - - } else { - std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T3ReleaseBus, CAN_BUS_tlc::_ProjectionWrite_T3ReleaseBus, CAN_BUS_tlc::_ProjectionRead_T3ReleaseBus::Hash, CAN_BUS_tlc::_ProjectionRead_T3ReleaseBus::HashEqual> _OpCache_with_parameter_T3ReleaseBus = _OpCache_with_parameter_T3ReleaseBus_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_T3ReleaseBus.find(readState); - if(writeState_ptr != _OpCache_with_parameter_T3ReleaseBus.end()) { - CAN_BUS_tlc::_ProjectionWrite_T3ReleaseBus writeState = writeState_ptr->second; - copiedState._apply_update_for_T3ReleaseBus(writeState); - } else { - copiedState.T3ReleaseBus(_tmp_1); - CAN_BUS_tlc::_ProjectionWrite_T3ReleaseBus writeState = copiedState._update_for_T3ReleaseBus(); - { - std::unique_lock<std::mutex> _ProjectionRead_T3ReleaseBus_lock(_ProjectionRead_T3ReleaseBus_mutex); - _OpCache_with_parameter_T3ReleaseBus.insert({readState, writeState}); - } + _OpCache_with_parameter_T3ReleaseBus.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "T3ReleaseBus"; - result.insert(copiedState); + copiedState.stateAccessedVia = "T3ReleaseBus"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } @@ -7484,7 +7191,10 @@ class ModelChecker { copiedState.stateAccessedVia = "T3Wait"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } CAN_BUS_tlc::_ProjectionRead__tr_T3ReEnableWait read__tr_T3ReEnableWait_state = state._projected_state_for__tr_T3ReEnableWait(); bool _trid_20; @@ -7531,90 +7241,61 @@ class ModelChecker { copiedState.stateAccessedVia = "T3ReEnableWait"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } CAN_BUS_tlc::_ProjectionRead__tr_Update read__tr_Update_state = state._projected_state_for__tr_Update(); + BSet<BInteger> _trid_21; auto _trid_21_ptr = _OpCache_tr_Update.find(read__tr_Update_state); if(_trid_21_ptr == _OpCache_tr_Update.end()) { - BSet<BInteger> _trid_21 = state._tr_Update(); + _trid_21 = state._tr_Update(); { std::unique_lock<std::mutex> _ProjectionRead__tr_Update_lock(_ProjectionRead__tr_Update_mutex); _OpCache_tr_Update.insert({read__tr_Update_state, _trid_21}); } - for(const BInteger& param : _trid_21) { - BInteger _tmp_1 = param; - - CAN_BUS_tlc copiedState = state._copy(); - CAN_BUS_tlc::_ProjectionRead_Update readState = state._projected_state_for_Update(); + } else { + _trid_21 = _trid_21_ptr->second; + } - auto _OpCache_with_parameter_Update_ptr = _OpCache_Update.find(param); - if(_OpCache_with_parameter_Update_ptr == _OpCache_Update.end()) { - copiedState.Update(_tmp_1); - CAN_BUS_tlc::_ProjectionWrite_Update writeState = copiedState._update_for_Update(); - std::unordered_map<CAN_BUS_tlc::_ProjectionRead_Update, CAN_BUS_tlc::_ProjectionWrite_Update, CAN_BUS_tlc::_ProjectionRead_Update::Hash, CAN_BUS_tlc::_ProjectionRead_Update::HashEqual> _OpCache_with_parameter_Update; - _OpCache_with_parameter_Update.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_Update_lock(_ProjectionRead_Update_mutex); - _OpCache_Update.insert({param, _OpCache_with_parameter_Update}); - } + for(const BInteger& param : _trid_21) { + BInteger _tmp_1 = param; - } else { - std::unordered_map<CAN_BUS_tlc::_ProjectionRead_Update, CAN_BUS_tlc::_ProjectionWrite_Update, CAN_BUS_tlc::_ProjectionRead_Update::Hash, CAN_BUS_tlc::_ProjectionRead_Update::HashEqual> _OpCache_with_parameter_Update = _OpCache_with_parameter_Update_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_Update.find(readState); - if(writeState_ptr != _OpCache_with_parameter_Update.end()) { - CAN_BUS_tlc::_ProjectionWrite_Update writeState = writeState_ptr->second; - copiedState._apply_update_for_Update(writeState); - } else { - copiedState.Update(_tmp_1); - CAN_BUS_tlc::_ProjectionWrite_Update writeState = copiedState._update_for_Update(); - { - std::unique_lock<std::mutex> _ProjectionRead_Update_lock(_ProjectionRead_Update_mutex); - _OpCache_with_parameter_Update.insert({readState, writeState}); - } - } + CAN_BUS_tlc copiedState = state._copy(); + CAN_BUS_tlc::_ProjectionRead_Update readState = state._projected_state_for_Update(); + + auto _OpCache_with_parameter_Update_ptr = _OpCache_Update.find(param); + if(_OpCache_with_parameter_Update_ptr == _OpCache_Update.end()) { + copiedState.Update(_tmp_1); + CAN_BUS_tlc::_ProjectionWrite_Update writeState = copiedState._update_for_Update(); + std::unordered_map<CAN_BUS_tlc::_ProjectionRead_Update, CAN_BUS_tlc::_ProjectionWrite_Update, CAN_BUS_tlc::_ProjectionRead_Update::Hash, CAN_BUS_tlc::_ProjectionRead_Update::HashEqual> _OpCache_with_parameter_Update; + _OpCache_with_parameter_Update.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_Update_lock(_ProjectionRead_Update_mutex); + _OpCache_Update.insert({param, _OpCache_with_parameter_Update}); } - copiedState.stateAccessedVia = "Update"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<BInteger> _trid_21 = _trid_21_ptr->second; - for(const BInteger& param : _trid_21) { - BInteger _tmp_1 = param; - - CAN_BUS_tlc copiedState = state._copy(); - CAN_BUS_tlc::_ProjectionRead_Update readState = state._projected_state_for_Update(); - - auto _OpCache_with_parameter_Update_ptr = _OpCache_Update.find(param); - if(_OpCache_with_parameter_Update_ptr == _OpCache_Update.end()) { + } else { + std::unordered_map<CAN_BUS_tlc::_ProjectionRead_Update, CAN_BUS_tlc::_ProjectionWrite_Update, CAN_BUS_tlc::_ProjectionRead_Update::Hash, CAN_BUS_tlc::_ProjectionRead_Update::HashEqual> _OpCache_with_parameter_Update = _OpCache_with_parameter_Update_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_Update.find(readState); + if(writeState_ptr != _OpCache_with_parameter_Update.end()) { + CAN_BUS_tlc::_ProjectionWrite_Update writeState = writeState_ptr->second; + copiedState._apply_update_for_Update(writeState); + } else { copiedState.Update(_tmp_1); CAN_BUS_tlc::_ProjectionWrite_Update writeState = copiedState._update_for_Update(); - std::unordered_map<CAN_BUS_tlc::_ProjectionRead_Update, CAN_BUS_tlc::_ProjectionWrite_Update, CAN_BUS_tlc::_ProjectionRead_Update::Hash, CAN_BUS_tlc::_ProjectionRead_Update::HashEqual> _OpCache_with_parameter_Update; - _OpCache_with_parameter_Update.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_Update_lock(_ProjectionRead_Update_mutex); - _OpCache_Update.insert({param, _OpCache_with_parameter_Update}); - } - - } else { - std::unordered_map<CAN_BUS_tlc::_ProjectionRead_Update, CAN_BUS_tlc::_ProjectionWrite_Update, CAN_BUS_tlc::_ProjectionRead_Update::Hash, CAN_BUS_tlc::_ProjectionRead_Update::HashEqual> _OpCache_with_parameter_Update = _OpCache_with_parameter_Update_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_Update.find(readState); - if(writeState_ptr != _OpCache_with_parameter_Update.end()) { - CAN_BUS_tlc::_ProjectionWrite_Update writeState = writeState_ptr->second; - copiedState._apply_update_for_Update(writeState); - } else { - copiedState.Update(_tmp_1); - CAN_BUS_tlc::_ProjectionWrite_Update writeState = copiedState._update_for_Update(); - { - std::unique_lock<std::mutex> _ProjectionRead_Update_lock(_ProjectionRead_Update_mutex); - _OpCache_with_parameter_Update.insert({readState, writeState}); - } + _OpCache_with_parameter_Update.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "Update"; - result.insert(copiedState); + copiedState.stateAccessedVia = "Update"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } @@ -7625,7 +7306,10 @@ class ModelChecker { copiedState.T1Evaluate(); copiedState.stateAccessedVia = "T1Evaluate"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<BInteger> _trid_2 = state._tr_T1Calculate(); for(const BInteger& param : _trid_2) { @@ -7635,7 +7319,10 @@ class ModelChecker { copiedState.T1Calculate(_tmp_1); copiedState.stateAccessedVia = "T1Calculate"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<BTuple<BInteger, BInteger >> _trid_3 = state._tr_T1SendResult(); for(const BTuple<BInteger, BInteger >& param : _trid_3) { @@ -7646,7 +7333,10 @@ class ModelChecker { copiedState.T1SendResult(_tmp_2, _tmp_1); copiedState.stateAccessedVia = "T1SendResult"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<BInteger> _trid_4 = state._tr_T1Wait(); for(const BInteger& param : _trid_4) { @@ -7656,14 +7346,20 @@ class ModelChecker { copiedState.T1Wait(_tmp_1); copiedState.stateAccessedVia = "T1Wait"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } if(state._tr_T2Evaluate()) { CAN_BUS_tlc copiedState = state._copy(); copiedState.T2Evaluate(); copiedState.stateAccessedVia = "T2Evaluate"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<BTuple<BInteger, BInteger >> _trid_6 = state._tr_T2ReadBus(); for(const BTuple<BInteger, BInteger >& param : _trid_6) { @@ -7674,21 +7370,30 @@ class ModelChecker { copiedState.T2ReadBus(_tmp_2, _tmp_1); copiedState.stateAccessedVia = "T2ReadBus"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } if(state._tr_T2Reset()) { CAN_BUS_tlc copiedState = state._copy(); copiedState.T2Reset(); copiedState.stateAccessedVia = "T2Reset"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } if(state._tr_T2Complete()) { CAN_BUS_tlc copiedState = state._copy(); copiedState.T2Complete(); copiedState.stateAccessedVia = "T2Complete"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<BInteger> _trid_9 = state._tr_T2ReleaseBus(); for(const BInteger& param : _trid_9) { @@ -7698,14 +7403,20 @@ class ModelChecker { copiedState.T2ReleaseBus(_tmp_1); copiedState.stateAccessedVia = "T2ReleaseBus"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } if(state._tr_T2Calculate()) { CAN_BUS_tlc copiedState = state._copy(); copiedState.T2Calculate(); copiedState.stateAccessedVia = "T2Calculate"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<BTuple<BInteger, BInteger >> _trid_11 = state._tr_T2WriteBus(); for(const BTuple<BInteger, BInteger >& param : _trid_11) { @@ -7716,7 +7427,10 @@ class ModelChecker { copiedState.T2WriteBus(_tmp_2, _tmp_1); copiedState.stateAccessedVia = "T2WriteBus"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<BInteger> _trid_12 = state._tr_T2Wait(); for(const BInteger& param : _trid_12) { @@ -7726,21 +7440,30 @@ class ModelChecker { copiedState.T2Wait(_tmp_1); copiedState.stateAccessedVia = "T2Wait"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } if(state._tr_T3Initiate()) { CAN_BUS_tlc copiedState = state._copy(); copiedState.T3Initiate(); copiedState.stateAccessedVia = "T3Initiate"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } if(state._tr_T3Evaluate()) { CAN_BUS_tlc copiedState = state._copy(); copiedState.T3Evaluate(); copiedState.stateAccessedVia = "T3Evaluate"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<BTuple<BInteger, BInteger >> _trid_15 = state._tr_T3writebus(); for(const BTuple<BInteger, BInteger >& param : _trid_15) { @@ -7751,7 +7474,10 @@ class ModelChecker { copiedState.T3writebus(_tmp_2, _tmp_1); copiedState.stateAccessedVia = "T3writebus"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<BTuple<BInteger, BInteger >> _trid_16 = state._tr_T3Read(); for(const BTuple<BInteger, BInteger >& param : _trid_16) { @@ -7762,14 +7488,20 @@ class ModelChecker { copiedState.T3Read(_tmp_2, _tmp_1); copiedState.stateAccessedVia = "T3Read"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } if(state._tr_T3Poll()) { CAN_BUS_tlc copiedState = state._copy(); copiedState.T3Poll(); copiedState.stateAccessedVia = "T3Poll"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<BInteger> _trid_18 = state._tr_T3ReleaseBus(); for(const BInteger& param : _trid_18) { @@ -7779,21 +7511,30 @@ class ModelChecker { copiedState.T3ReleaseBus(_tmp_1); copiedState.stateAccessedVia = "T3ReleaseBus"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } if(state._tr_T3Wait()) { CAN_BUS_tlc copiedState = state._copy(); copiedState.T3Wait(); copiedState.stateAccessedVia = "T3Wait"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } if(state._tr_T3ReEnableWait()) { CAN_BUS_tlc copiedState = state._copy(); copiedState.T3ReEnableWait(); copiedState.stateAccessedVia = "T3ReEnableWait"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<BInteger> _trid_21 = state._tr_Update(); for(const BInteger& param : _trid_21) { @@ -7803,7 +7544,10 @@ class ModelChecker { copiedState.Update(_tmp_1); copiedState.stateAccessedVia = "Update"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } } diff --git a/benchmarks/model_checking_opreuse/C++/Cruise_finite1_deterministic_MC.cpp b/benchmarks/model_checking_opreuse/C++/Cruise_finite1_deterministic_MC.cpp index 17be0a899ec94f516575c8a213d4486448a1c5ff..997336871a764b7413557ee1acf710dd86899da2 100644 --- a/benchmarks/model_checking_opreuse/C++/Cruise_finite1_deterministic_MC.cpp +++ b/benchmarks/model_checking_opreuse/C++/Cruise_finite1_deterministic_MC.cpp @@ -10,7 +10,6 @@ #include <atomic> #include <any> #include <mutex> -#include <shared_mutex> #include <future> #include <boost/asio/post.hpp> #include <boost/asio/thread_pool.hpp> @@ -8610,12 +8609,16 @@ class ModelChecker { states.insert(machine); unvisitedStates.push_back(machine); - std::atomic<bool> stopThreads(false); + std::atomic<bool> stopThreads; + stopThreads = false; std::atomic<int> possibleQueueChanges; possibleQueueChanges = 0; - while(!unvisitedStates.empty() && !stopThreads.load()) { - possibleQueueChanges.fetch_add(1); + std::atomic<bool> waitFlag; + waitFlag = true; + + while(!unvisitedStates.empty() && !stopThreads) { + possibleQueueChanges += 1; Cruise_finite1_deterministic_MC state = next(); std::packaged_task<void()> task([&, state] { std::unordered_set<Cruise_finite1_deterministic_MC, Cruise_finite1_deterministic_MC::Hash, Cruise_finite1_deterministic_MC::HashEqual> nextStates = generateNextStates(state); @@ -8636,12 +8639,14 @@ class ModelChecker { } } - possibleQueueChanges.fetch_sub(1); { std::unique_lock<std::mutex> lock(mutex); - if (!unvisitedStates.empty() || possibleQueueChanges.load() == 0) { + possibleQueueChanges -= 1; + int running = possibleQueueChanges; + if (!unvisitedStates.empty() || running == 0) { { std::unique_lock<std::mutex> lock(waitMutex); + waitFlag = false; waitCV.notify_one(); } } @@ -8651,24 +8656,27 @@ class ModelChecker { if(invariantViolated(state)) { invariantViolatedBool = true; counterExampleState = state; - stopThreads.store(true); + stopThreads = true; } if(nextStates.empty()) { deadlockDetected = true; counterExampleState = state; - stopThreads.store(true); + stopThreads = true; } }); + waitFlag = true; boost::asio::post(workers, std::move(task)); { std::unique_lock<std::mutex> lock(waitMutex); - waitCV.wait(lock, [&] { - return !unvisitedStates.empty() || possibleQueueChanges == 0; - }); + if(unvisitedStates.empty() && possibleQueueChanges > 0) { + waitCV.wait(lock, [&] { + return waitFlag == false; + }); + } } } workers.join(); @@ -8757,7 +8765,10 @@ class ModelChecker { copiedState.stateAccessedVia = "CruiseBecomesNotAllowed"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } Cruise_finite1_deterministic_MC::_ProjectionRead__tr_CruiseBecomesAllowed read__tr_CruiseBecomesAllowed_state = state._projected_state_for__tr_CruiseBecomesAllowed(); bool _trid_2; @@ -8804,179 +8815,116 @@ class ModelChecker { copiedState.stateAccessedVia = "CruiseBecomesAllowed"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } Cruise_finite1_deterministic_MC::_ProjectionRead__tr_SetCruiseSpeed read__tr_SetCruiseSpeed_state = state._projected_state_for__tr_SetCruiseSpeed(); + BSet<BTuple<BBoolean, BBoolean >> _trid_3; auto _trid_3_ptr = _OpCache_tr_SetCruiseSpeed.find(read__tr_SetCruiseSpeed_state); if(_trid_3_ptr == _OpCache_tr_SetCruiseSpeed.end()) { - BSet<BTuple<BBoolean, BBoolean >> _trid_3 = state._tr_SetCruiseSpeed(); + _trid_3 = state._tr_SetCruiseSpeed(); { std::unique_lock<std::mutex> _ProjectionRead__tr_SetCruiseSpeed_lock(_ProjectionRead__tr_SetCruiseSpeed_mutex); _OpCache_tr_SetCruiseSpeed.insert({read__tr_SetCruiseSpeed_state, _trid_3}); } - for(const BTuple<BBoolean, BBoolean >& param : _trid_3) { - BBoolean _tmp_1 = param.projection2(); - BBoolean _tmp_2 = param.projection1(); - - Cruise_finite1_deterministic_MC copiedState = state._copy(); - Cruise_finite1_deterministic_MC::_ProjectionRead_SetCruiseSpeed readState = state._projected_state_for_SetCruiseSpeed(); + } else { + _trid_3 = _trid_3_ptr->second; + } - auto _OpCache_with_parameter_SetCruiseSpeed_ptr = _OpCache_SetCruiseSpeed.find(param); - if(_OpCache_with_parameter_SetCruiseSpeed_ptr == _OpCache_SetCruiseSpeed.end()) { - copiedState.SetCruiseSpeed(_tmp_2, _tmp_1); - Cruise_finite1_deterministic_MC::_ProjectionWrite_SetCruiseSpeed writeState = copiedState._update_for_SetCruiseSpeed(); - std::unordered_map<Cruise_finite1_deterministic_MC::_ProjectionRead_SetCruiseSpeed, Cruise_finite1_deterministic_MC::_ProjectionWrite_SetCruiseSpeed, Cruise_finite1_deterministic_MC::_ProjectionRead_SetCruiseSpeed::Hash, Cruise_finite1_deterministic_MC::_ProjectionRead_SetCruiseSpeed::HashEqual> _OpCache_with_parameter_SetCruiseSpeed; - _OpCache_with_parameter_SetCruiseSpeed.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_SetCruiseSpeed_lock(_ProjectionRead_SetCruiseSpeed_mutex); - _OpCache_SetCruiseSpeed.insert({param, _OpCache_with_parameter_SetCruiseSpeed}); - } + for(const BTuple<BBoolean, BBoolean >& param : _trid_3) { + BBoolean _tmp_1 = param.projection2(); + BBoolean _tmp_2 = param.projection1(); - } else { - std::unordered_map<Cruise_finite1_deterministic_MC::_ProjectionRead_SetCruiseSpeed, Cruise_finite1_deterministic_MC::_ProjectionWrite_SetCruiseSpeed, Cruise_finite1_deterministic_MC::_ProjectionRead_SetCruiseSpeed::Hash, Cruise_finite1_deterministic_MC::_ProjectionRead_SetCruiseSpeed::HashEqual> _OpCache_with_parameter_SetCruiseSpeed = _OpCache_with_parameter_SetCruiseSpeed_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_SetCruiseSpeed.find(readState); - if(writeState_ptr != _OpCache_with_parameter_SetCruiseSpeed.end()) { - Cruise_finite1_deterministic_MC::_ProjectionWrite_SetCruiseSpeed writeState = writeState_ptr->second; - copiedState._apply_update_for_SetCruiseSpeed(writeState); - } else { - copiedState.SetCruiseSpeed(_tmp_2, _tmp_1); - Cruise_finite1_deterministic_MC::_ProjectionWrite_SetCruiseSpeed writeState = copiedState._update_for_SetCruiseSpeed(); - { - std::unique_lock<std::mutex> _ProjectionRead_SetCruiseSpeed_lock(_ProjectionRead_SetCruiseSpeed_mutex); - _OpCache_with_parameter_SetCruiseSpeed.insert({readState, writeState}); - } - } + Cruise_finite1_deterministic_MC copiedState = state._copy(); + Cruise_finite1_deterministic_MC::_ProjectionRead_SetCruiseSpeed readState = state._projected_state_for_SetCruiseSpeed(); + + auto _OpCache_with_parameter_SetCruiseSpeed_ptr = _OpCache_SetCruiseSpeed.find(param); + if(_OpCache_with_parameter_SetCruiseSpeed_ptr == _OpCache_SetCruiseSpeed.end()) { + copiedState.SetCruiseSpeed(_tmp_2, _tmp_1); + Cruise_finite1_deterministic_MC::_ProjectionWrite_SetCruiseSpeed writeState = copiedState._update_for_SetCruiseSpeed(); + std::unordered_map<Cruise_finite1_deterministic_MC::_ProjectionRead_SetCruiseSpeed, Cruise_finite1_deterministic_MC::_ProjectionWrite_SetCruiseSpeed, Cruise_finite1_deterministic_MC::_ProjectionRead_SetCruiseSpeed::Hash, Cruise_finite1_deterministic_MC::_ProjectionRead_SetCruiseSpeed::HashEqual> _OpCache_with_parameter_SetCruiseSpeed; + _OpCache_with_parameter_SetCruiseSpeed.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_SetCruiseSpeed_lock(_ProjectionRead_SetCruiseSpeed_mutex); + _OpCache_SetCruiseSpeed.insert({param, _OpCache_with_parameter_SetCruiseSpeed}); } - copiedState.stateAccessedVia = "SetCruiseSpeed"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<BTuple<BBoolean, BBoolean >> _trid_3 = _trid_3_ptr->second; - for(const BTuple<BBoolean, BBoolean >& param : _trid_3) { - BBoolean _tmp_1 = param.projection2(); - BBoolean _tmp_2 = param.projection1(); - - Cruise_finite1_deterministic_MC copiedState = state._copy(); - Cruise_finite1_deterministic_MC::_ProjectionRead_SetCruiseSpeed readState = state._projected_state_for_SetCruiseSpeed(); - - auto _OpCache_with_parameter_SetCruiseSpeed_ptr = _OpCache_SetCruiseSpeed.find(param); - if(_OpCache_with_parameter_SetCruiseSpeed_ptr == _OpCache_SetCruiseSpeed.end()) { + } else { + std::unordered_map<Cruise_finite1_deterministic_MC::_ProjectionRead_SetCruiseSpeed, Cruise_finite1_deterministic_MC::_ProjectionWrite_SetCruiseSpeed, Cruise_finite1_deterministic_MC::_ProjectionRead_SetCruiseSpeed::Hash, Cruise_finite1_deterministic_MC::_ProjectionRead_SetCruiseSpeed::HashEqual> _OpCache_with_parameter_SetCruiseSpeed = _OpCache_with_parameter_SetCruiseSpeed_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_SetCruiseSpeed.find(readState); + if(writeState_ptr != _OpCache_with_parameter_SetCruiseSpeed.end()) { + Cruise_finite1_deterministic_MC::_ProjectionWrite_SetCruiseSpeed writeState = writeState_ptr->second; + copiedState._apply_update_for_SetCruiseSpeed(writeState); + } else { copiedState.SetCruiseSpeed(_tmp_2, _tmp_1); Cruise_finite1_deterministic_MC::_ProjectionWrite_SetCruiseSpeed writeState = copiedState._update_for_SetCruiseSpeed(); - std::unordered_map<Cruise_finite1_deterministic_MC::_ProjectionRead_SetCruiseSpeed, Cruise_finite1_deterministic_MC::_ProjectionWrite_SetCruiseSpeed, Cruise_finite1_deterministic_MC::_ProjectionRead_SetCruiseSpeed::Hash, Cruise_finite1_deterministic_MC::_ProjectionRead_SetCruiseSpeed::HashEqual> _OpCache_with_parameter_SetCruiseSpeed; - _OpCache_with_parameter_SetCruiseSpeed.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_SetCruiseSpeed_lock(_ProjectionRead_SetCruiseSpeed_mutex); - _OpCache_SetCruiseSpeed.insert({param, _OpCache_with_parameter_SetCruiseSpeed}); - } - - } else { - std::unordered_map<Cruise_finite1_deterministic_MC::_ProjectionRead_SetCruiseSpeed, Cruise_finite1_deterministic_MC::_ProjectionWrite_SetCruiseSpeed, Cruise_finite1_deterministic_MC::_ProjectionRead_SetCruiseSpeed::Hash, Cruise_finite1_deterministic_MC::_ProjectionRead_SetCruiseSpeed::HashEqual> _OpCache_with_parameter_SetCruiseSpeed = _OpCache_with_parameter_SetCruiseSpeed_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_SetCruiseSpeed.find(readState); - if(writeState_ptr != _OpCache_with_parameter_SetCruiseSpeed.end()) { - Cruise_finite1_deterministic_MC::_ProjectionWrite_SetCruiseSpeed writeState = writeState_ptr->second; - copiedState._apply_update_for_SetCruiseSpeed(writeState); - } else { - copiedState.SetCruiseSpeed(_tmp_2, _tmp_1); - Cruise_finite1_deterministic_MC::_ProjectionWrite_SetCruiseSpeed writeState = copiedState._update_for_SetCruiseSpeed(); - { - std::unique_lock<std::mutex> _ProjectionRead_SetCruiseSpeed_lock(_ProjectionRead_SetCruiseSpeed_mutex); - _OpCache_with_parameter_SetCruiseSpeed.insert({readState, writeState}); - } + _OpCache_with_parameter_SetCruiseSpeed.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "SetCruiseSpeed"; - result.insert(copiedState); + copiedState.stateAccessedVia = "SetCruiseSpeed"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } Cruise_finite1_deterministic_MC::_ProjectionRead__tr_CCInitialisationFinished read__tr_CCInitialisationFinished_state = state._projected_state_for__tr_CCInitialisationFinished(); + BSet<BTuple<BBoolean, BBoolean >> _trid_4; auto _trid_4_ptr = _OpCache_tr_CCInitialisationFinished.find(read__tr_CCInitialisationFinished_state); if(_trid_4_ptr == _OpCache_tr_CCInitialisationFinished.end()) { - BSet<BTuple<BBoolean, BBoolean >> _trid_4 = state._tr_CCInitialisationFinished(); + _trid_4 = state._tr_CCInitialisationFinished(); { std::unique_lock<std::mutex> _ProjectionRead__tr_CCInitialisationFinished_lock(_ProjectionRead__tr_CCInitialisationFinished_mutex); _OpCache_tr_CCInitialisationFinished.insert({read__tr_CCInitialisationFinished_state, _trid_4}); } - for(const BTuple<BBoolean, BBoolean >& param : _trid_4) { - BBoolean _tmp_1 = param.projection2(); - BBoolean _tmp_2 = param.projection1(); - - Cruise_finite1_deterministic_MC copiedState = state._copy(); - Cruise_finite1_deterministic_MC::_ProjectionRead_CCInitialisationFinished readState = state._projected_state_for_CCInitialisationFinished(); + } else { + _trid_4 = _trid_4_ptr->second; + } - auto _OpCache_with_parameter_CCInitialisationFinished_ptr = _OpCache_CCInitialisationFinished.find(param); - if(_OpCache_with_parameter_CCInitialisationFinished_ptr == _OpCache_CCInitialisationFinished.end()) { - copiedState.CCInitialisationFinished(_tmp_2, _tmp_1); - Cruise_finite1_deterministic_MC::_ProjectionWrite_CCInitialisationFinished writeState = copiedState._update_for_CCInitialisationFinished(); - std::unordered_map<Cruise_finite1_deterministic_MC::_ProjectionRead_CCInitialisationFinished, Cruise_finite1_deterministic_MC::_ProjectionWrite_CCInitialisationFinished, Cruise_finite1_deterministic_MC::_ProjectionRead_CCInitialisationFinished::Hash, Cruise_finite1_deterministic_MC::_ProjectionRead_CCInitialisationFinished::HashEqual> _OpCache_with_parameter_CCInitialisationFinished; - _OpCache_with_parameter_CCInitialisationFinished.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_CCInitialisationFinished_lock(_ProjectionRead_CCInitialisationFinished_mutex); - _OpCache_CCInitialisationFinished.insert({param, _OpCache_with_parameter_CCInitialisationFinished}); - } + for(const BTuple<BBoolean, BBoolean >& param : _trid_4) { + BBoolean _tmp_1 = param.projection2(); + BBoolean _tmp_2 = param.projection1(); - } else { - std::unordered_map<Cruise_finite1_deterministic_MC::_ProjectionRead_CCInitialisationFinished, Cruise_finite1_deterministic_MC::_ProjectionWrite_CCInitialisationFinished, Cruise_finite1_deterministic_MC::_ProjectionRead_CCInitialisationFinished::Hash, Cruise_finite1_deterministic_MC::_ProjectionRead_CCInitialisationFinished::HashEqual> _OpCache_with_parameter_CCInitialisationFinished = _OpCache_with_parameter_CCInitialisationFinished_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_CCInitialisationFinished.find(readState); - if(writeState_ptr != _OpCache_with_parameter_CCInitialisationFinished.end()) { - Cruise_finite1_deterministic_MC::_ProjectionWrite_CCInitialisationFinished writeState = writeState_ptr->second; - copiedState._apply_update_for_CCInitialisationFinished(writeState); - } else { - copiedState.CCInitialisationFinished(_tmp_2, _tmp_1); - Cruise_finite1_deterministic_MC::_ProjectionWrite_CCInitialisationFinished writeState = copiedState._update_for_CCInitialisationFinished(); - { - std::unique_lock<std::mutex> _ProjectionRead_CCInitialisationFinished_lock(_ProjectionRead_CCInitialisationFinished_mutex); - _OpCache_with_parameter_CCInitialisationFinished.insert({readState, writeState}); - } - } + Cruise_finite1_deterministic_MC copiedState = state._copy(); + Cruise_finite1_deterministic_MC::_ProjectionRead_CCInitialisationFinished readState = state._projected_state_for_CCInitialisationFinished(); + + auto _OpCache_with_parameter_CCInitialisationFinished_ptr = _OpCache_CCInitialisationFinished.find(param); + if(_OpCache_with_parameter_CCInitialisationFinished_ptr == _OpCache_CCInitialisationFinished.end()) { + copiedState.CCInitialisationFinished(_tmp_2, _tmp_1); + Cruise_finite1_deterministic_MC::_ProjectionWrite_CCInitialisationFinished writeState = copiedState._update_for_CCInitialisationFinished(); + std::unordered_map<Cruise_finite1_deterministic_MC::_ProjectionRead_CCInitialisationFinished, Cruise_finite1_deterministic_MC::_ProjectionWrite_CCInitialisationFinished, Cruise_finite1_deterministic_MC::_ProjectionRead_CCInitialisationFinished::Hash, Cruise_finite1_deterministic_MC::_ProjectionRead_CCInitialisationFinished::HashEqual> _OpCache_with_parameter_CCInitialisationFinished; + _OpCache_with_parameter_CCInitialisationFinished.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_CCInitialisationFinished_lock(_ProjectionRead_CCInitialisationFinished_mutex); + _OpCache_CCInitialisationFinished.insert({param, _OpCache_with_parameter_CCInitialisationFinished}); } - copiedState.stateAccessedVia = "CCInitialisationFinished"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<BTuple<BBoolean, BBoolean >> _trid_4 = _trid_4_ptr->second; - for(const BTuple<BBoolean, BBoolean >& param : _trid_4) { - BBoolean _tmp_1 = param.projection2(); - BBoolean _tmp_2 = param.projection1(); - - Cruise_finite1_deterministic_MC copiedState = state._copy(); - Cruise_finite1_deterministic_MC::_ProjectionRead_CCInitialisationFinished readState = state._projected_state_for_CCInitialisationFinished(); - - auto _OpCache_with_parameter_CCInitialisationFinished_ptr = _OpCache_CCInitialisationFinished.find(param); - if(_OpCache_with_parameter_CCInitialisationFinished_ptr == _OpCache_CCInitialisationFinished.end()) { + } else { + std::unordered_map<Cruise_finite1_deterministic_MC::_ProjectionRead_CCInitialisationFinished, Cruise_finite1_deterministic_MC::_ProjectionWrite_CCInitialisationFinished, Cruise_finite1_deterministic_MC::_ProjectionRead_CCInitialisationFinished::Hash, Cruise_finite1_deterministic_MC::_ProjectionRead_CCInitialisationFinished::HashEqual> _OpCache_with_parameter_CCInitialisationFinished = _OpCache_with_parameter_CCInitialisationFinished_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_CCInitialisationFinished.find(readState); + if(writeState_ptr != _OpCache_with_parameter_CCInitialisationFinished.end()) { + Cruise_finite1_deterministic_MC::_ProjectionWrite_CCInitialisationFinished writeState = writeState_ptr->second; + copiedState._apply_update_for_CCInitialisationFinished(writeState); + } else { copiedState.CCInitialisationFinished(_tmp_2, _tmp_1); Cruise_finite1_deterministic_MC::_ProjectionWrite_CCInitialisationFinished writeState = copiedState._update_for_CCInitialisationFinished(); - std::unordered_map<Cruise_finite1_deterministic_MC::_ProjectionRead_CCInitialisationFinished, Cruise_finite1_deterministic_MC::_ProjectionWrite_CCInitialisationFinished, Cruise_finite1_deterministic_MC::_ProjectionRead_CCInitialisationFinished::Hash, Cruise_finite1_deterministic_MC::_ProjectionRead_CCInitialisationFinished::HashEqual> _OpCache_with_parameter_CCInitialisationFinished; - _OpCache_with_parameter_CCInitialisationFinished.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_CCInitialisationFinished_lock(_ProjectionRead_CCInitialisationFinished_mutex); - _OpCache_CCInitialisationFinished.insert({param, _OpCache_with_parameter_CCInitialisationFinished}); - } - - } else { - std::unordered_map<Cruise_finite1_deterministic_MC::_ProjectionRead_CCInitialisationFinished, Cruise_finite1_deterministic_MC::_ProjectionWrite_CCInitialisationFinished, Cruise_finite1_deterministic_MC::_ProjectionRead_CCInitialisationFinished::Hash, Cruise_finite1_deterministic_MC::_ProjectionRead_CCInitialisationFinished::HashEqual> _OpCache_with_parameter_CCInitialisationFinished = _OpCache_with_parameter_CCInitialisationFinished_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_CCInitialisationFinished.find(readState); - if(writeState_ptr != _OpCache_with_parameter_CCInitialisationFinished.end()) { - Cruise_finite1_deterministic_MC::_ProjectionWrite_CCInitialisationFinished writeState = writeState_ptr->second; - copiedState._apply_update_for_CCInitialisationFinished(writeState); - } else { - copiedState.CCInitialisationFinished(_tmp_2, _tmp_1); - Cruise_finite1_deterministic_MC::_ProjectionWrite_CCInitialisationFinished writeState = copiedState._update_for_CCInitialisationFinished(); - { - std::unique_lock<std::mutex> _ProjectionRead_CCInitialisationFinished_lock(_ProjectionRead_CCInitialisationFinished_mutex); - _OpCache_with_parameter_CCInitialisationFinished.insert({readState, writeState}); - } + _OpCache_with_parameter_CCInitialisationFinished.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "CCInitialisationFinished"; - result.insert(copiedState); + copiedState.stateAccessedVia = "CCInitialisationFinished"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } @@ -9025,92 +8973,62 @@ class ModelChecker { copiedState.stateAccessedVia = "CCInitialisationDelayFinished"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } Cruise_finite1_deterministic_MC::_ProjectionRead__tr_CruiseSpeedChangeFinished read__tr_CruiseSpeedChangeFinished_state = state._projected_state_for__tr_CruiseSpeedChangeFinished(); + BSet<BTuple<BBoolean, BBoolean >> _trid_6; auto _trid_6_ptr = _OpCache_tr_CruiseSpeedChangeFinished.find(read__tr_CruiseSpeedChangeFinished_state); if(_trid_6_ptr == _OpCache_tr_CruiseSpeedChangeFinished.end()) { - BSet<BTuple<BBoolean, BBoolean >> _trid_6 = state._tr_CruiseSpeedChangeFinished(); + _trid_6 = state._tr_CruiseSpeedChangeFinished(); { std::unique_lock<std::mutex> _ProjectionRead__tr_CruiseSpeedChangeFinished_lock(_ProjectionRead__tr_CruiseSpeedChangeFinished_mutex); _OpCache_tr_CruiseSpeedChangeFinished.insert({read__tr_CruiseSpeedChangeFinished_state, _trid_6}); } - for(const BTuple<BBoolean, BBoolean >& param : _trid_6) { - BBoolean _tmp_1 = param.projection2(); - BBoolean _tmp_2 = param.projection1(); - - Cruise_finite1_deterministic_MC copiedState = state._copy(); - Cruise_finite1_deterministic_MC::_ProjectionRead_CruiseSpeedChangeFinished readState = state._projected_state_for_CruiseSpeedChangeFinished(); + } else { + _trid_6 = _trid_6_ptr->second; + } - auto _OpCache_with_parameter_CruiseSpeedChangeFinished_ptr = _OpCache_CruiseSpeedChangeFinished.find(param); - if(_OpCache_with_parameter_CruiseSpeedChangeFinished_ptr == _OpCache_CruiseSpeedChangeFinished.end()) { - copiedState.CruiseSpeedChangeFinished(_tmp_2, _tmp_1); - Cruise_finite1_deterministic_MC::_ProjectionWrite_CruiseSpeedChangeFinished writeState = copiedState._update_for_CruiseSpeedChangeFinished(); - std::unordered_map<Cruise_finite1_deterministic_MC::_ProjectionRead_CruiseSpeedChangeFinished, Cruise_finite1_deterministic_MC::_ProjectionWrite_CruiseSpeedChangeFinished, Cruise_finite1_deterministic_MC::_ProjectionRead_CruiseSpeedChangeFinished::Hash, Cruise_finite1_deterministic_MC::_ProjectionRead_CruiseSpeedChangeFinished::HashEqual> _OpCache_with_parameter_CruiseSpeedChangeFinished; - _OpCache_with_parameter_CruiseSpeedChangeFinished.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_CruiseSpeedChangeFinished_lock(_ProjectionRead_CruiseSpeedChangeFinished_mutex); - _OpCache_CruiseSpeedChangeFinished.insert({param, _OpCache_with_parameter_CruiseSpeedChangeFinished}); - } + for(const BTuple<BBoolean, BBoolean >& param : _trid_6) { + BBoolean _tmp_1 = param.projection2(); + BBoolean _tmp_2 = param.projection1(); - } else { - std::unordered_map<Cruise_finite1_deterministic_MC::_ProjectionRead_CruiseSpeedChangeFinished, Cruise_finite1_deterministic_MC::_ProjectionWrite_CruiseSpeedChangeFinished, Cruise_finite1_deterministic_MC::_ProjectionRead_CruiseSpeedChangeFinished::Hash, Cruise_finite1_deterministic_MC::_ProjectionRead_CruiseSpeedChangeFinished::HashEqual> _OpCache_with_parameter_CruiseSpeedChangeFinished = _OpCache_with_parameter_CruiseSpeedChangeFinished_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_CruiseSpeedChangeFinished.find(readState); - if(writeState_ptr != _OpCache_with_parameter_CruiseSpeedChangeFinished.end()) { - Cruise_finite1_deterministic_MC::_ProjectionWrite_CruiseSpeedChangeFinished writeState = writeState_ptr->second; - copiedState._apply_update_for_CruiseSpeedChangeFinished(writeState); - } else { - copiedState.CruiseSpeedChangeFinished(_tmp_2, _tmp_1); - Cruise_finite1_deterministic_MC::_ProjectionWrite_CruiseSpeedChangeFinished writeState = copiedState._update_for_CruiseSpeedChangeFinished(); - { - std::unique_lock<std::mutex> _ProjectionRead_CruiseSpeedChangeFinished_lock(_ProjectionRead_CruiseSpeedChangeFinished_mutex); - _OpCache_with_parameter_CruiseSpeedChangeFinished.insert({readState, writeState}); - } - } + Cruise_finite1_deterministic_MC copiedState = state._copy(); + Cruise_finite1_deterministic_MC::_ProjectionRead_CruiseSpeedChangeFinished readState = state._projected_state_for_CruiseSpeedChangeFinished(); + + auto _OpCache_with_parameter_CruiseSpeedChangeFinished_ptr = _OpCache_CruiseSpeedChangeFinished.find(param); + if(_OpCache_with_parameter_CruiseSpeedChangeFinished_ptr == _OpCache_CruiseSpeedChangeFinished.end()) { + copiedState.CruiseSpeedChangeFinished(_tmp_2, _tmp_1); + Cruise_finite1_deterministic_MC::_ProjectionWrite_CruiseSpeedChangeFinished writeState = copiedState._update_for_CruiseSpeedChangeFinished(); + std::unordered_map<Cruise_finite1_deterministic_MC::_ProjectionRead_CruiseSpeedChangeFinished, Cruise_finite1_deterministic_MC::_ProjectionWrite_CruiseSpeedChangeFinished, Cruise_finite1_deterministic_MC::_ProjectionRead_CruiseSpeedChangeFinished::Hash, Cruise_finite1_deterministic_MC::_ProjectionRead_CruiseSpeedChangeFinished::HashEqual> _OpCache_with_parameter_CruiseSpeedChangeFinished; + _OpCache_with_parameter_CruiseSpeedChangeFinished.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_CruiseSpeedChangeFinished_lock(_ProjectionRead_CruiseSpeedChangeFinished_mutex); + _OpCache_CruiseSpeedChangeFinished.insert({param, _OpCache_with_parameter_CruiseSpeedChangeFinished}); } - copiedState.stateAccessedVia = "CruiseSpeedChangeFinished"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<BTuple<BBoolean, BBoolean >> _trid_6 = _trid_6_ptr->second; - for(const BTuple<BBoolean, BBoolean >& param : _trid_6) { - BBoolean _tmp_1 = param.projection2(); - BBoolean _tmp_2 = param.projection1(); - - Cruise_finite1_deterministic_MC copiedState = state._copy(); - Cruise_finite1_deterministic_MC::_ProjectionRead_CruiseSpeedChangeFinished readState = state._projected_state_for_CruiseSpeedChangeFinished(); - - auto _OpCache_with_parameter_CruiseSpeedChangeFinished_ptr = _OpCache_CruiseSpeedChangeFinished.find(param); - if(_OpCache_with_parameter_CruiseSpeedChangeFinished_ptr == _OpCache_CruiseSpeedChangeFinished.end()) { + } else { + std::unordered_map<Cruise_finite1_deterministic_MC::_ProjectionRead_CruiseSpeedChangeFinished, Cruise_finite1_deterministic_MC::_ProjectionWrite_CruiseSpeedChangeFinished, Cruise_finite1_deterministic_MC::_ProjectionRead_CruiseSpeedChangeFinished::Hash, Cruise_finite1_deterministic_MC::_ProjectionRead_CruiseSpeedChangeFinished::HashEqual> _OpCache_with_parameter_CruiseSpeedChangeFinished = _OpCache_with_parameter_CruiseSpeedChangeFinished_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_CruiseSpeedChangeFinished.find(readState); + if(writeState_ptr != _OpCache_with_parameter_CruiseSpeedChangeFinished.end()) { + Cruise_finite1_deterministic_MC::_ProjectionWrite_CruiseSpeedChangeFinished writeState = writeState_ptr->second; + copiedState._apply_update_for_CruiseSpeedChangeFinished(writeState); + } else { copiedState.CruiseSpeedChangeFinished(_tmp_2, _tmp_1); Cruise_finite1_deterministic_MC::_ProjectionWrite_CruiseSpeedChangeFinished writeState = copiedState._update_for_CruiseSpeedChangeFinished(); - std::unordered_map<Cruise_finite1_deterministic_MC::_ProjectionRead_CruiseSpeedChangeFinished, Cruise_finite1_deterministic_MC::_ProjectionWrite_CruiseSpeedChangeFinished, Cruise_finite1_deterministic_MC::_ProjectionRead_CruiseSpeedChangeFinished::Hash, Cruise_finite1_deterministic_MC::_ProjectionRead_CruiseSpeedChangeFinished::HashEqual> _OpCache_with_parameter_CruiseSpeedChangeFinished; - _OpCache_with_parameter_CruiseSpeedChangeFinished.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_CruiseSpeedChangeFinished_lock(_ProjectionRead_CruiseSpeedChangeFinished_mutex); - _OpCache_CruiseSpeedChangeFinished.insert({param, _OpCache_with_parameter_CruiseSpeedChangeFinished}); - } - - } else { - std::unordered_map<Cruise_finite1_deterministic_MC::_ProjectionRead_CruiseSpeedChangeFinished, Cruise_finite1_deterministic_MC::_ProjectionWrite_CruiseSpeedChangeFinished, Cruise_finite1_deterministic_MC::_ProjectionRead_CruiseSpeedChangeFinished::Hash, Cruise_finite1_deterministic_MC::_ProjectionRead_CruiseSpeedChangeFinished::HashEqual> _OpCache_with_parameter_CruiseSpeedChangeFinished = _OpCache_with_parameter_CruiseSpeedChangeFinished_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_CruiseSpeedChangeFinished.find(readState); - if(writeState_ptr != _OpCache_with_parameter_CruiseSpeedChangeFinished.end()) { - Cruise_finite1_deterministic_MC::_ProjectionWrite_CruiseSpeedChangeFinished writeState = writeState_ptr->second; - copiedState._apply_update_for_CruiseSpeedChangeFinished(writeState); - } else { - copiedState.CruiseSpeedChangeFinished(_tmp_2, _tmp_1); - Cruise_finite1_deterministic_MC::_ProjectionWrite_CruiseSpeedChangeFinished writeState = copiedState._update_for_CruiseSpeedChangeFinished(); - { - std::unique_lock<std::mutex> _ProjectionRead_CruiseSpeedChangeFinished_lock(_ProjectionRead_CruiseSpeedChangeFinished_mutex); - _OpCache_with_parameter_CruiseSpeedChangeFinished.insert({readState, writeState}); - } + _OpCache_with_parameter_CruiseSpeedChangeFinished.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "CruiseSpeedChangeFinished"; - result.insert(copiedState); + copiedState.stateAccessedVia = "CruiseSpeedChangeFinished"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } @@ -9159,7 +9077,10 @@ class ModelChecker { copiedState.stateAccessedVia = "CruiseSpeedChangeDelayFinished"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } Cruise_finite1_deterministic_MC::_ProjectionRead__tr_CruiseOff read__tr_CruiseOff_state = state._projected_state_for__tr_CruiseOff(); bool _trid_8; @@ -9206,7 +9127,10 @@ class ModelChecker { copiedState.stateAccessedVia = "CruiseOff"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } Cruise_finite1_deterministic_MC::_ProjectionRead__tr_ExternalForcesBecomesExtreme read__tr_ExternalForcesBecomesExtreme_state = state._projected_state_for__tr_ExternalForcesBecomesExtreme(); bool _trid_9; @@ -9253,7 +9177,10 @@ class ModelChecker { copiedState.stateAccessedVia = "ExternalForcesBecomesExtreme"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } Cruise_finite1_deterministic_MC::_ProjectionRead__tr_ExternalForcesBecomesNormal read__tr_ExternalForcesBecomesNormal_state = state._projected_state_for__tr_ExternalForcesBecomesNormal(); bool _trid_10; @@ -9300,7 +9227,10 @@ class ModelChecker { copiedState.stateAccessedVia = "ExternalForcesBecomesNormal"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } Cruise_finite1_deterministic_MC::_ProjectionRead__tr_VehicleLeavesCruiseSpeed read__tr_VehicleLeavesCruiseSpeed_state = state._projected_state_for__tr_VehicleLeavesCruiseSpeed(); bool _trid_11; @@ -9347,7 +9277,10 @@ class ModelChecker { copiedState.stateAccessedVia = "VehicleLeavesCruiseSpeed"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } Cruise_finite1_deterministic_MC::_ProjectionRead__tr_VehicleReachesCruiseSpeed read__tr_VehicleReachesCruiseSpeed_state = state._projected_state_for__tr_VehicleReachesCruiseSpeed(); bool _trid_12; @@ -9394,7 +9327,10 @@ class ModelChecker { copiedState.stateAccessedVia = "VehicleReachesCruiseSpeed"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } Cruise_finite1_deterministic_MC::_ProjectionRead__tr_VehicleExceedsMaxCruiseSpeed read__tr_VehicleExceedsMaxCruiseSpeed_state = state._projected_state_for__tr_VehicleExceedsMaxCruiseSpeed(); bool _trid_13; @@ -9441,7 +9377,10 @@ class ModelChecker { copiedState.stateAccessedVia = "VehicleExceedsMaxCruiseSpeed"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } Cruise_finite1_deterministic_MC::_ProjectionRead__tr_VehicleFallsBelowMaxCruiseSpeed read__tr_VehicleFallsBelowMaxCruiseSpeed_state = state._projected_state_for__tr_VehicleFallsBelowMaxCruiseSpeed(); bool _trid_14; @@ -9488,7 +9427,10 @@ class ModelChecker { copiedState.stateAccessedVia = "VehicleFallsBelowMaxCruiseSpeed"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } Cruise_finite1_deterministic_MC::_ProjectionRead__tr_ObstacleDistanceBecomesVeryClose read__tr_ObstacleDistanceBecomesVeryClose_state = state._projected_state_for__tr_ObstacleDistanceBecomesVeryClose(); bool _trid_15; @@ -9535,7 +9477,10 @@ class ModelChecker { copiedState.stateAccessedVia = "ObstacleDistanceBecomesVeryClose"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } Cruise_finite1_deterministic_MC::_ProjectionRead__tr_ObstacleDistanceBecomesClose read__tr_ObstacleDistanceBecomesClose_state = state._projected_state_for__tr_ObstacleDistanceBecomesClose(); bool _trid_16; @@ -9582,7 +9527,10 @@ class ModelChecker { copiedState.stateAccessedVia = "ObstacleDistanceBecomesClose"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } Cruise_finite1_deterministic_MC::_ProjectionRead__tr_ObstacleDistanceBecomesBig read__tr_ObstacleDistanceBecomesBig_state = state._projected_state_for__tr_ObstacleDistanceBecomesBig(); bool _trid_17; @@ -9629,7 +9577,10 @@ class ModelChecker { copiedState.stateAccessedVia = "ObstacleDistanceBecomesBig"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } Cruise_finite1_deterministic_MC::_ProjectionRead__tr_ObstacleStartsTravelFaster read__tr_ObstacleStartsTravelFaster_state = state._projected_state_for__tr_ObstacleStartsTravelFaster(); bool _trid_18; @@ -9676,7 +9627,10 @@ class ModelChecker { copiedState.stateAccessedVia = "ObstacleStartsTravelFaster"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } Cruise_finite1_deterministic_MC::_ProjectionRead__tr_ObstacleStopsTravelFaster read__tr_ObstacleStopsTravelFaster_state = state._projected_state_for__tr_ObstacleStopsTravelFaster(); bool _trid_19; @@ -9723,7 +9677,10 @@ class ModelChecker { copiedState.stateAccessedVia = "ObstacleStopsTravelFaster"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } Cruise_finite1_deterministic_MC::_ProjectionRead__tr_ObstacleStartsTravelSlower read__tr_ObstacleStartsTravelSlower_state = state._projected_state_for__tr_ObstacleStartsTravelSlower(); bool _trid_20; @@ -9770,7 +9727,10 @@ class ModelChecker { copiedState.stateAccessedVia = "ObstacleStartsTravelSlower"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } Cruise_finite1_deterministic_MC::_ProjectionRead__tr_ObstacleStopsTravelSlower read__tr_ObstacleStopsTravelSlower_state = state._projected_state_for__tr_ObstacleStopsTravelSlower(); bool _trid_21; @@ -9817,177 +9777,115 @@ class ModelChecker { copiedState.stateAccessedVia = "ObstacleStopsTravelSlower"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } Cruise_finite1_deterministic_MC::_ProjectionRead__tr_ObstacleAppearsWhenCruiseActive read__tr_ObstacleAppearsWhenCruiseActive_state = state._projected_state_for__tr_ObstacleAppearsWhenCruiseActive(); + BSet<BTuple<Cruise_finite1_deterministic_MC::RSset, Cruise_finite1_deterministic_MC::ODset >> _trid_22; auto _trid_22_ptr = _OpCache_tr_ObstacleAppearsWhenCruiseActive.find(read__tr_ObstacleAppearsWhenCruiseActive_state); if(_trid_22_ptr == _OpCache_tr_ObstacleAppearsWhenCruiseActive.end()) { - BSet<BTuple<Cruise_finite1_deterministic_MC::RSset, Cruise_finite1_deterministic_MC::ODset >> _trid_22 = state._tr_ObstacleAppearsWhenCruiseActive(); + _trid_22 = state._tr_ObstacleAppearsWhenCruiseActive(); { std::unique_lock<std::mutex> _ProjectionRead__tr_ObstacleAppearsWhenCruiseActive_lock(_ProjectionRead__tr_ObstacleAppearsWhenCruiseActive_mutex); _OpCache_tr_ObstacleAppearsWhenCruiseActive.insert({read__tr_ObstacleAppearsWhenCruiseActive_state, _trid_22}); } - for(const BTuple<Cruise_finite1_deterministic_MC::RSset, Cruise_finite1_deterministic_MC::ODset >& param : _trid_22) { - Cruise_finite1_deterministic_MC::ODset _tmp_1 = param.projection2(); - Cruise_finite1_deterministic_MC::RSset _tmp_2 = param.projection1(); - - Cruise_finite1_deterministic_MC copiedState = state._copy(); - Cruise_finite1_deterministic_MC::_ProjectionRead_ObstacleAppearsWhenCruiseActive readState = state._projected_state_for_ObstacleAppearsWhenCruiseActive(); + } else { + _trid_22 = _trid_22_ptr->second; + } - auto _OpCache_with_parameter_ObstacleAppearsWhenCruiseActive_ptr = _OpCache_ObstacleAppearsWhenCruiseActive.find(param); - if(_OpCache_with_parameter_ObstacleAppearsWhenCruiseActive_ptr == _OpCache_ObstacleAppearsWhenCruiseActive.end()) { - copiedState.ObstacleAppearsWhenCruiseActive(_tmp_2, _tmp_1); - Cruise_finite1_deterministic_MC::_ProjectionWrite_ObstacleAppearsWhenCruiseActive writeState = copiedState._update_for_ObstacleAppearsWhenCruiseActive(); - std::unordered_map<Cruise_finite1_deterministic_MC::_ProjectionRead_ObstacleAppearsWhenCruiseActive, Cruise_finite1_deterministic_MC::_ProjectionWrite_ObstacleAppearsWhenCruiseActive, Cruise_finite1_deterministic_MC::_ProjectionRead_ObstacleAppearsWhenCruiseActive::Hash, Cruise_finite1_deterministic_MC::_ProjectionRead_ObstacleAppearsWhenCruiseActive::HashEqual> _OpCache_with_parameter_ObstacleAppearsWhenCruiseActive; - _OpCache_with_parameter_ObstacleAppearsWhenCruiseActive.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_ObstacleAppearsWhenCruiseActive_lock(_ProjectionRead_ObstacleAppearsWhenCruiseActive_mutex); - _OpCache_ObstacleAppearsWhenCruiseActive.insert({param, _OpCache_with_parameter_ObstacleAppearsWhenCruiseActive}); - } + for(const BTuple<Cruise_finite1_deterministic_MC::RSset, Cruise_finite1_deterministic_MC::ODset >& param : _trid_22) { + Cruise_finite1_deterministic_MC::ODset _tmp_1 = param.projection2(); + Cruise_finite1_deterministic_MC::RSset _tmp_2 = param.projection1(); - } else { - std::unordered_map<Cruise_finite1_deterministic_MC::_ProjectionRead_ObstacleAppearsWhenCruiseActive, Cruise_finite1_deterministic_MC::_ProjectionWrite_ObstacleAppearsWhenCruiseActive, Cruise_finite1_deterministic_MC::_ProjectionRead_ObstacleAppearsWhenCruiseActive::Hash, Cruise_finite1_deterministic_MC::_ProjectionRead_ObstacleAppearsWhenCruiseActive::HashEqual> _OpCache_with_parameter_ObstacleAppearsWhenCruiseActive = _OpCache_with_parameter_ObstacleAppearsWhenCruiseActive_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_ObstacleAppearsWhenCruiseActive.find(readState); - if(writeState_ptr != _OpCache_with_parameter_ObstacleAppearsWhenCruiseActive.end()) { - Cruise_finite1_deterministic_MC::_ProjectionWrite_ObstacleAppearsWhenCruiseActive writeState = writeState_ptr->second; - copiedState._apply_update_for_ObstacleAppearsWhenCruiseActive(writeState); - } else { - copiedState.ObstacleAppearsWhenCruiseActive(_tmp_2, _tmp_1); - Cruise_finite1_deterministic_MC::_ProjectionWrite_ObstacleAppearsWhenCruiseActive writeState = copiedState._update_for_ObstacleAppearsWhenCruiseActive(); - { - std::unique_lock<std::mutex> _ProjectionRead_ObstacleAppearsWhenCruiseActive_lock(_ProjectionRead_ObstacleAppearsWhenCruiseActive_mutex); - _OpCache_with_parameter_ObstacleAppearsWhenCruiseActive.insert({readState, writeState}); - } - } + Cruise_finite1_deterministic_MC copiedState = state._copy(); + Cruise_finite1_deterministic_MC::_ProjectionRead_ObstacleAppearsWhenCruiseActive readState = state._projected_state_for_ObstacleAppearsWhenCruiseActive(); + + auto _OpCache_with_parameter_ObstacleAppearsWhenCruiseActive_ptr = _OpCache_ObstacleAppearsWhenCruiseActive.find(param); + if(_OpCache_with_parameter_ObstacleAppearsWhenCruiseActive_ptr == _OpCache_ObstacleAppearsWhenCruiseActive.end()) { + copiedState.ObstacleAppearsWhenCruiseActive(_tmp_2, _tmp_1); + Cruise_finite1_deterministic_MC::_ProjectionWrite_ObstacleAppearsWhenCruiseActive writeState = copiedState._update_for_ObstacleAppearsWhenCruiseActive(); + std::unordered_map<Cruise_finite1_deterministic_MC::_ProjectionRead_ObstacleAppearsWhenCruiseActive, Cruise_finite1_deterministic_MC::_ProjectionWrite_ObstacleAppearsWhenCruiseActive, Cruise_finite1_deterministic_MC::_ProjectionRead_ObstacleAppearsWhenCruiseActive::Hash, Cruise_finite1_deterministic_MC::_ProjectionRead_ObstacleAppearsWhenCruiseActive::HashEqual> _OpCache_with_parameter_ObstacleAppearsWhenCruiseActive; + _OpCache_with_parameter_ObstacleAppearsWhenCruiseActive.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_ObstacleAppearsWhenCruiseActive_lock(_ProjectionRead_ObstacleAppearsWhenCruiseActive_mutex); + _OpCache_ObstacleAppearsWhenCruiseActive.insert({param, _OpCache_with_parameter_ObstacleAppearsWhenCruiseActive}); } - copiedState.stateAccessedVia = "ObstacleAppearsWhenCruiseActive"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<BTuple<Cruise_finite1_deterministic_MC::RSset, Cruise_finite1_deterministic_MC::ODset >> _trid_22 = _trid_22_ptr->second; - for(const BTuple<Cruise_finite1_deterministic_MC::RSset, Cruise_finite1_deterministic_MC::ODset >& param : _trid_22) { - Cruise_finite1_deterministic_MC::ODset _tmp_1 = param.projection2(); - Cruise_finite1_deterministic_MC::RSset _tmp_2 = param.projection1(); - - Cruise_finite1_deterministic_MC copiedState = state._copy(); - Cruise_finite1_deterministic_MC::_ProjectionRead_ObstacleAppearsWhenCruiseActive readState = state._projected_state_for_ObstacleAppearsWhenCruiseActive(); - - auto _OpCache_with_parameter_ObstacleAppearsWhenCruiseActive_ptr = _OpCache_ObstacleAppearsWhenCruiseActive.find(param); - if(_OpCache_with_parameter_ObstacleAppearsWhenCruiseActive_ptr == _OpCache_ObstacleAppearsWhenCruiseActive.end()) { + } else { + std::unordered_map<Cruise_finite1_deterministic_MC::_ProjectionRead_ObstacleAppearsWhenCruiseActive, Cruise_finite1_deterministic_MC::_ProjectionWrite_ObstacleAppearsWhenCruiseActive, Cruise_finite1_deterministic_MC::_ProjectionRead_ObstacleAppearsWhenCruiseActive::Hash, Cruise_finite1_deterministic_MC::_ProjectionRead_ObstacleAppearsWhenCruiseActive::HashEqual> _OpCache_with_parameter_ObstacleAppearsWhenCruiseActive = _OpCache_with_parameter_ObstacleAppearsWhenCruiseActive_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_ObstacleAppearsWhenCruiseActive.find(readState); + if(writeState_ptr != _OpCache_with_parameter_ObstacleAppearsWhenCruiseActive.end()) { + Cruise_finite1_deterministic_MC::_ProjectionWrite_ObstacleAppearsWhenCruiseActive writeState = writeState_ptr->second; + copiedState._apply_update_for_ObstacleAppearsWhenCruiseActive(writeState); + } else { copiedState.ObstacleAppearsWhenCruiseActive(_tmp_2, _tmp_1); Cruise_finite1_deterministic_MC::_ProjectionWrite_ObstacleAppearsWhenCruiseActive writeState = copiedState._update_for_ObstacleAppearsWhenCruiseActive(); - std::unordered_map<Cruise_finite1_deterministic_MC::_ProjectionRead_ObstacleAppearsWhenCruiseActive, Cruise_finite1_deterministic_MC::_ProjectionWrite_ObstacleAppearsWhenCruiseActive, Cruise_finite1_deterministic_MC::_ProjectionRead_ObstacleAppearsWhenCruiseActive::Hash, Cruise_finite1_deterministic_MC::_ProjectionRead_ObstacleAppearsWhenCruiseActive::HashEqual> _OpCache_with_parameter_ObstacleAppearsWhenCruiseActive; - _OpCache_with_parameter_ObstacleAppearsWhenCruiseActive.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_ObstacleAppearsWhenCruiseActive_lock(_ProjectionRead_ObstacleAppearsWhenCruiseActive_mutex); - _OpCache_ObstacleAppearsWhenCruiseActive.insert({param, _OpCache_with_parameter_ObstacleAppearsWhenCruiseActive}); - } - - } else { - std::unordered_map<Cruise_finite1_deterministic_MC::_ProjectionRead_ObstacleAppearsWhenCruiseActive, Cruise_finite1_deterministic_MC::_ProjectionWrite_ObstacleAppearsWhenCruiseActive, Cruise_finite1_deterministic_MC::_ProjectionRead_ObstacleAppearsWhenCruiseActive::Hash, Cruise_finite1_deterministic_MC::_ProjectionRead_ObstacleAppearsWhenCruiseActive::HashEqual> _OpCache_with_parameter_ObstacleAppearsWhenCruiseActive = _OpCache_with_parameter_ObstacleAppearsWhenCruiseActive_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_ObstacleAppearsWhenCruiseActive.find(readState); - if(writeState_ptr != _OpCache_with_parameter_ObstacleAppearsWhenCruiseActive.end()) { - Cruise_finite1_deterministic_MC::_ProjectionWrite_ObstacleAppearsWhenCruiseActive writeState = writeState_ptr->second; - copiedState._apply_update_for_ObstacleAppearsWhenCruiseActive(writeState); - } else { - copiedState.ObstacleAppearsWhenCruiseActive(_tmp_2, _tmp_1); - Cruise_finite1_deterministic_MC::_ProjectionWrite_ObstacleAppearsWhenCruiseActive writeState = copiedState._update_for_ObstacleAppearsWhenCruiseActive(); - { - std::unique_lock<std::mutex> _ProjectionRead_ObstacleAppearsWhenCruiseActive_lock(_ProjectionRead_ObstacleAppearsWhenCruiseActive_mutex); - _OpCache_with_parameter_ObstacleAppearsWhenCruiseActive.insert({readState, writeState}); - } + _OpCache_with_parameter_ObstacleAppearsWhenCruiseActive.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "ObstacleAppearsWhenCruiseActive"; - result.insert(copiedState); + copiedState.stateAccessedVia = "ObstacleAppearsWhenCruiseActive"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } Cruise_finite1_deterministic_MC::_ProjectionRead__tr_ObstacleAppearsWhenCruiseInactive read__tr_ObstacleAppearsWhenCruiseInactive_state = state._projected_state_for__tr_ObstacleAppearsWhenCruiseInactive(); + BSet<Cruise_finite1_deterministic_MC::RSset> _trid_23; auto _trid_23_ptr = _OpCache_tr_ObstacleAppearsWhenCruiseInactive.find(read__tr_ObstacleAppearsWhenCruiseInactive_state); if(_trid_23_ptr == _OpCache_tr_ObstacleAppearsWhenCruiseInactive.end()) { - BSet<Cruise_finite1_deterministic_MC::RSset> _trid_23 = state._tr_ObstacleAppearsWhenCruiseInactive(); + _trid_23 = state._tr_ObstacleAppearsWhenCruiseInactive(); { std::unique_lock<std::mutex> _ProjectionRead__tr_ObstacleAppearsWhenCruiseInactive_lock(_ProjectionRead__tr_ObstacleAppearsWhenCruiseInactive_mutex); _OpCache_tr_ObstacleAppearsWhenCruiseInactive.insert({read__tr_ObstacleAppearsWhenCruiseInactive_state, _trid_23}); } - for(const Cruise_finite1_deterministic_MC::RSset& param : _trid_23) { - Cruise_finite1_deterministic_MC::RSset _tmp_1 = param; - - Cruise_finite1_deterministic_MC copiedState = state._copy(); - Cruise_finite1_deterministic_MC::_ProjectionRead_ObstacleAppearsWhenCruiseInactive readState = state._projected_state_for_ObstacleAppearsWhenCruiseInactive(); + } else { + _trid_23 = _trid_23_ptr->second; + } - auto _OpCache_with_parameter_ObstacleAppearsWhenCruiseInactive_ptr = _OpCache_ObstacleAppearsWhenCruiseInactive.find(param); - if(_OpCache_with_parameter_ObstacleAppearsWhenCruiseInactive_ptr == _OpCache_ObstacleAppearsWhenCruiseInactive.end()) { - copiedState.ObstacleAppearsWhenCruiseInactive(_tmp_1); - Cruise_finite1_deterministic_MC::_ProjectionWrite_ObstacleAppearsWhenCruiseInactive writeState = copiedState._update_for_ObstacleAppearsWhenCruiseInactive(); - std::unordered_map<Cruise_finite1_deterministic_MC::_ProjectionRead_ObstacleAppearsWhenCruiseInactive, Cruise_finite1_deterministic_MC::_ProjectionWrite_ObstacleAppearsWhenCruiseInactive, Cruise_finite1_deterministic_MC::_ProjectionRead_ObstacleAppearsWhenCruiseInactive::Hash, Cruise_finite1_deterministic_MC::_ProjectionRead_ObstacleAppearsWhenCruiseInactive::HashEqual> _OpCache_with_parameter_ObstacleAppearsWhenCruiseInactive; - _OpCache_with_parameter_ObstacleAppearsWhenCruiseInactive.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_ObstacleAppearsWhenCruiseInactive_lock(_ProjectionRead_ObstacleAppearsWhenCruiseInactive_mutex); - _OpCache_ObstacleAppearsWhenCruiseInactive.insert({param, _OpCache_with_parameter_ObstacleAppearsWhenCruiseInactive}); - } + for(const Cruise_finite1_deterministic_MC::RSset& param : _trid_23) { + Cruise_finite1_deterministic_MC::RSset _tmp_1 = param; - } else { - std::unordered_map<Cruise_finite1_deterministic_MC::_ProjectionRead_ObstacleAppearsWhenCruiseInactive, Cruise_finite1_deterministic_MC::_ProjectionWrite_ObstacleAppearsWhenCruiseInactive, Cruise_finite1_deterministic_MC::_ProjectionRead_ObstacleAppearsWhenCruiseInactive::Hash, Cruise_finite1_deterministic_MC::_ProjectionRead_ObstacleAppearsWhenCruiseInactive::HashEqual> _OpCache_with_parameter_ObstacleAppearsWhenCruiseInactive = _OpCache_with_parameter_ObstacleAppearsWhenCruiseInactive_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_ObstacleAppearsWhenCruiseInactive.find(readState); - if(writeState_ptr != _OpCache_with_parameter_ObstacleAppearsWhenCruiseInactive.end()) { - Cruise_finite1_deterministic_MC::_ProjectionWrite_ObstacleAppearsWhenCruiseInactive writeState = writeState_ptr->second; - copiedState._apply_update_for_ObstacleAppearsWhenCruiseInactive(writeState); - } else { - copiedState.ObstacleAppearsWhenCruiseInactive(_tmp_1); - Cruise_finite1_deterministic_MC::_ProjectionWrite_ObstacleAppearsWhenCruiseInactive writeState = copiedState._update_for_ObstacleAppearsWhenCruiseInactive(); - { - std::unique_lock<std::mutex> _ProjectionRead_ObstacleAppearsWhenCruiseInactive_lock(_ProjectionRead_ObstacleAppearsWhenCruiseInactive_mutex); - _OpCache_with_parameter_ObstacleAppearsWhenCruiseInactive.insert({readState, writeState}); - } - } + Cruise_finite1_deterministic_MC copiedState = state._copy(); + Cruise_finite1_deterministic_MC::_ProjectionRead_ObstacleAppearsWhenCruiseInactive readState = state._projected_state_for_ObstacleAppearsWhenCruiseInactive(); + + auto _OpCache_with_parameter_ObstacleAppearsWhenCruiseInactive_ptr = _OpCache_ObstacleAppearsWhenCruiseInactive.find(param); + if(_OpCache_with_parameter_ObstacleAppearsWhenCruiseInactive_ptr == _OpCache_ObstacleAppearsWhenCruiseInactive.end()) { + copiedState.ObstacleAppearsWhenCruiseInactive(_tmp_1); + Cruise_finite1_deterministic_MC::_ProjectionWrite_ObstacleAppearsWhenCruiseInactive writeState = copiedState._update_for_ObstacleAppearsWhenCruiseInactive(); + std::unordered_map<Cruise_finite1_deterministic_MC::_ProjectionRead_ObstacleAppearsWhenCruiseInactive, Cruise_finite1_deterministic_MC::_ProjectionWrite_ObstacleAppearsWhenCruiseInactive, Cruise_finite1_deterministic_MC::_ProjectionRead_ObstacleAppearsWhenCruiseInactive::Hash, Cruise_finite1_deterministic_MC::_ProjectionRead_ObstacleAppearsWhenCruiseInactive::HashEqual> _OpCache_with_parameter_ObstacleAppearsWhenCruiseInactive; + _OpCache_with_parameter_ObstacleAppearsWhenCruiseInactive.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_ObstacleAppearsWhenCruiseInactive_lock(_ProjectionRead_ObstacleAppearsWhenCruiseInactive_mutex); + _OpCache_ObstacleAppearsWhenCruiseInactive.insert({param, _OpCache_with_parameter_ObstacleAppearsWhenCruiseInactive}); } - copiedState.stateAccessedVia = "ObstacleAppearsWhenCruiseInactive"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<Cruise_finite1_deterministic_MC::RSset> _trid_23 = _trid_23_ptr->second; - for(const Cruise_finite1_deterministic_MC::RSset& param : _trid_23) { - Cruise_finite1_deterministic_MC::RSset _tmp_1 = param; - - Cruise_finite1_deterministic_MC copiedState = state._copy(); - Cruise_finite1_deterministic_MC::_ProjectionRead_ObstacleAppearsWhenCruiseInactive readState = state._projected_state_for_ObstacleAppearsWhenCruiseInactive(); - - auto _OpCache_with_parameter_ObstacleAppearsWhenCruiseInactive_ptr = _OpCache_ObstacleAppearsWhenCruiseInactive.find(param); - if(_OpCache_with_parameter_ObstacleAppearsWhenCruiseInactive_ptr == _OpCache_ObstacleAppearsWhenCruiseInactive.end()) { + } else { + std::unordered_map<Cruise_finite1_deterministic_MC::_ProjectionRead_ObstacleAppearsWhenCruiseInactive, Cruise_finite1_deterministic_MC::_ProjectionWrite_ObstacleAppearsWhenCruiseInactive, Cruise_finite1_deterministic_MC::_ProjectionRead_ObstacleAppearsWhenCruiseInactive::Hash, Cruise_finite1_deterministic_MC::_ProjectionRead_ObstacleAppearsWhenCruiseInactive::HashEqual> _OpCache_with_parameter_ObstacleAppearsWhenCruiseInactive = _OpCache_with_parameter_ObstacleAppearsWhenCruiseInactive_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_ObstacleAppearsWhenCruiseInactive.find(readState); + if(writeState_ptr != _OpCache_with_parameter_ObstacleAppearsWhenCruiseInactive.end()) { + Cruise_finite1_deterministic_MC::_ProjectionWrite_ObstacleAppearsWhenCruiseInactive writeState = writeState_ptr->second; + copiedState._apply_update_for_ObstacleAppearsWhenCruiseInactive(writeState); + } else { copiedState.ObstacleAppearsWhenCruiseInactive(_tmp_1); Cruise_finite1_deterministic_MC::_ProjectionWrite_ObstacleAppearsWhenCruiseInactive writeState = copiedState._update_for_ObstacleAppearsWhenCruiseInactive(); - std::unordered_map<Cruise_finite1_deterministic_MC::_ProjectionRead_ObstacleAppearsWhenCruiseInactive, Cruise_finite1_deterministic_MC::_ProjectionWrite_ObstacleAppearsWhenCruiseInactive, Cruise_finite1_deterministic_MC::_ProjectionRead_ObstacleAppearsWhenCruiseInactive::Hash, Cruise_finite1_deterministic_MC::_ProjectionRead_ObstacleAppearsWhenCruiseInactive::HashEqual> _OpCache_with_parameter_ObstacleAppearsWhenCruiseInactive; - _OpCache_with_parameter_ObstacleAppearsWhenCruiseInactive.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_ObstacleAppearsWhenCruiseInactive_lock(_ProjectionRead_ObstacleAppearsWhenCruiseInactive_mutex); - _OpCache_ObstacleAppearsWhenCruiseInactive.insert({param, _OpCache_with_parameter_ObstacleAppearsWhenCruiseInactive}); - } - - } else { - std::unordered_map<Cruise_finite1_deterministic_MC::_ProjectionRead_ObstacleAppearsWhenCruiseInactive, Cruise_finite1_deterministic_MC::_ProjectionWrite_ObstacleAppearsWhenCruiseInactive, Cruise_finite1_deterministic_MC::_ProjectionRead_ObstacleAppearsWhenCruiseInactive::Hash, Cruise_finite1_deterministic_MC::_ProjectionRead_ObstacleAppearsWhenCruiseInactive::HashEqual> _OpCache_with_parameter_ObstacleAppearsWhenCruiseInactive = _OpCache_with_parameter_ObstacleAppearsWhenCruiseInactive_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_ObstacleAppearsWhenCruiseInactive.find(readState); - if(writeState_ptr != _OpCache_with_parameter_ObstacleAppearsWhenCruiseInactive.end()) { - Cruise_finite1_deterministic_MC::_ProjectionWrite_ObstacleAppearsWhenCruiseInactive writeState = writeState_ptr->second; - copiedState._apply_update_for_ObstacleAppearsWhenCruiseInactive(writeState); - } else { - copiedState.ObstacleAppearsWhenCruiseInactive(_tmp_1); - Cruise_finite1_deterministic_MC::_ProjectionWrite_ObstacleAppearsWhenCruiseInactive writeState = copiedState._update_for_ObstacleAppearsWhenCruiseInactive(); - { - std::unique_lock<std::mutex> _ProjectionRead_ObstacleAppearsWhenCruiseInactive_lock(_ProjectionRead_ObstacleAppearsWhenCruiseInactive_mutex); - _OpCache_with_parameter_ObstacleAppearsWhenCruiseInactive.insert({readState, writeState}); - } + _OpCache_with_parameter_ObstacleAppearsWhenCruiseInactive.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "ObstacleAppearsWhenCruiseInactive"; - result.insert(copiedState); + copiedState.stateAccessedVia = "ObstacleAppearsWhenCruiseInactive"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } @@ -10036,92 +9934,62 @@ class ModelChecker { copiedState.stateAccessedVia = "ObstacleDisappears"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } Cruise_finite1_deterministic_MC::_ProjectionRead__tr_VehicleManageObstacle read__tr_VehicleManageObstacle_state = state._projected_state_for__tr_VehicleManageObstacle(); + BSet<BTuple<BBoolean, BBoolean >> _trid_25; auto _trid_25_ptr = _OpCache_tr_VehicleManageObstacle.find(read__tr_VehicleManageObstacle_state); if(_trid_25_ptr == _OpCache_tr_VehicleManageObstacle.end()) { - BSet<BTuple<BBoolean, BBoolean >> _trid_25 = state._tr_VehicleManageObstacle(); + _trid_25 = state._tr_VehicleManageObstacle(); { std::unique_lock<std::mutex> _ProjectionRead__tr_VehicleManageObstacle_lock(_ProjectionRead__tr_VehicleManageObstacle_mutex); _OpCache_tr_VehicleManageObstacle.insert({read__tr_VehicleManageObstacle_state, _trid_25}); } - for(const BTuple<BBoolean, BBoolean >& param : _trid_25) { - BBoolean _tmp_1 = param.projection2(); - BBoolean _tmp_2 = param.projection1(); - - Cruise_finite1_deterministic_MC copiedState = state._copy(); - Cruise_finite1_deterministic_MC::_ProjectionRead_VehicleManageObstacle readState = state._projected_state_for_VehicleManageObstacle(); + } else { + _trid_25 = _trid_25_ptr->second; + } - auto _OpCache_with_parameter_VehicleManageObstacle_ptr = _OpCache_VehicleManageObstacle.find(param); - if(_OpCache_with_parameter_VehicleManageObstacle_ptr == _OpCache_VehicleManageObstacle.end()) { - copiedState.VehicleManageObstacle(_tmp_2, _tmp_1); - Cruise_finite1_deterministic_MC::_ProjectionWrite_VehicleManageObstacle writeState = copiedState._update_for_VehicleManageObstacle(); - std::unordered_map<Cruise_finite1_deterministic_MC::_ProjectionRead_VehicleManageObstacle, Cruise_finite1_deterministic_MC::_ProjectionWrite_VehicleManageObstacle, Cruise_finite1_deterministic_MC::_ProjectionRead_VehicleManageObstacle::Hash, Cruise_finite1_deterministic_MC::_ProjectionRead_VehicleManageObstacle::HashEqual> _OpCache_with_parameter_VehicleManageObstacle; - _OpCache_with_parameter_VehicleManageObstacle.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_VehicleManageObstacle_lock(_ProjectionRead_VehicleManageObstacle_mutex); - _OpCache_VehicleManageObstacle.insert({param, _OpCache_with_parameter_VehicleManageObstacle}); - } + for(const BTuple<BBoolean, BBoolean >& param : _trid_25) { + BBoolean _tmp_1 = param.projection2(); + BBoolean _tmp_2 = param.projection1(); - } else { - std::unordered_map<Cruise_finite1_deterministic_MC::_ProjectionRead_VehicleManageObstacle, Cruise_finite1_deterministic_MC::_ProjectionWrite_VehicleManageObstacle, Cruise_finite1_deterministic_MC::_ProjectionRead_VehicleManageObstacle::Hash, Cruise_finite1_deterministic_MC::_ProjectionRead_VehicleManageObstacle::HashEqual> _OpCache_with_parameter_VehicleManageObstacle = _OpCache_with_parameter_VehicleManageObstacle_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_VehicleManageObstacle.find(readState); - if(writeState_ptr != _OpCache_with_parameter_VehicleManageObstacle.end()) { - Cruise_finite1_deterministic_MC::_ProjectionWrite_VehicleManageObstacle writeState = writeState_ptr->second; - copiedState._apply_update_for_VehicleManageObstacle(writeState); - } else { - copiedState.VehicleManageObstacle(_tmp_2, _tmp_1); - Cruise_finite1_deterministic_MC::_ProjectionWrite_VehicleManageObstacle writeState = copiedState._update_for_VehicleManageObstacle(); - { - std::unique_lock<std::mutex> _ProjectionRead_VehicleManageObstacle_lock(_ProjectionRead_VehicleManageObstacle_mutex); - _OpCache_with_parameter_VehicleManageObstacle.insert({readState, writeState}); - } - } + Cruise_finite1_deterministic_MC copiedState = state._copy(); + Cruise_finite1_deterministic_MC::_ProjectionRead_VehicleManageObstacle readState = state._projected_state_for_VehicleManageObstacle(); + + auto _OpCache_with_parameter_VehicleManageObstacle_ptr = _OpCache_VehicleManageObstacle.find(param); + if(_OpCache_with_parameter_VehicleManageObstacle_ptr == _OpCache_VehicleManageObstacle.end()) { + copiedState.VehicleManageObstacle(_tmp_2, _tmp_1); + Cruise_finite1_deterministic_MC::_ProjectionWrite_VehicleManageObstacle writeState = copiedState._update_for_VehicleManageObstacle(); + std::unordered_map<Cruise_finite1_deterministic_MC::_ProjectionRead_VehicleManageObstacle, Cruise_finite1_deterministic_MC::_ProjectionWrite_VehicleManageObstacle, Cruise_finite1_deterministic_MC::_ProjectionRead_VehicleManageObstacle::Hash, Cruise_finite1_deterministic_MC::_ProjectionRead_VehicleManageObstacle::HashEqual> _OpCache_with_parameter_VehicleManageObstacle; + _OpCache_with_parameter_VehicleManageObstacle.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_VehicleManageObstacle_lock(_ProjectionRead_VehicleManageObstacle_mutex); + _OpCache_VehicleManageObstacle.insert({param, _OpCache_with_parameter_VehicleManageObstacle}); } - copiedState.stateAccessedVia = "VehicleManageObstacle"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<BTuple<BBoolean, BBoolean >> _trid_25 = _trid_25_ptr->second; - for(const BTuple<BBoolean, BBoolean >& param : _trid_25) { - BBoolean _tmp_1 = param.projection2(); - BBoolean _tmp_2 = param.projection1(); - - Cruise_finite1_deterministic_MC copiedState = state._copy(); - Cruise_finite1_deterministic_MC::_ProjectionRead_VehicleManageObstacle readState = state._projected_state_for_VehicleManageObstacle(); - - auto _OpCache_with_parameter_VehicleManageObstacle_ptr = _OpCache_VehicleManageObstacle.find(param); - if(_OpCache_with_parameter_VehicleManageObstacle_ptr == _OpCache_VehicleManageObstacle.end()) { + } else { + std::unordered_map<Cruise_finite1_deterministic_MC::_ProjectionRead_VehicleManageObstacle, Cruise_finite1_deterministic_MC::_ProjectionWrite_VehicleManageObstacle, Cruise_finite1_deterministic_MC::_ProjectionRead_VehicleManageObstacle::Hash, Cruise_finite1_deterministic_MC::_ProjectionRead_VehicleManageObstacle::HashEqual> _OpCache_with_parameter_VehicleManageObstacle = _OpCache_with_parameter_VehicleManageObstacle_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_VehicleManageObstacle.find(readState); + if(writeState_ptr != _OpCache_with_parameter_VehicleManageObstacle.end()) { + Cruise_finite1_deterministic_MC::_ProjectionWrite_VehicleManageObstacle writeState = writeState_ptr->second; + copiedState._apply_update_for_VehicleManageObstacle(writeState); + } else { copiedState.VehicleManageObstacle(_tmp_2, _tmp_1); Cruise_finite1_deterministic_MC::_ProjectionWrite_VehicleManageObstacle writeState = copiedState._update_for_VehicleManageObstacle(); - std::unordered_map<Cruise_finite1_deterministic_MC::_ProjectionRead_VehicleManageObstacle, Cruise_finite1_deterministic_MC::_ProjectionWrite_VehicleManageObstacle, Cruise_finite1_deterministic_MC::_ProjectionRead_VehicleManageObstacle::Hash, Cruise_finite1_deterministic_MC::_ProjectionRead_VehicleManageObstacle::HashEqual> _OpCache_with_parameter_VehicleManageObstacle; - _OpCache_with_parameter_VehicleManageObstacle.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_VehicleManageObstacle_lock(_ProjectionRead_VehicleManageObstacle_mutex); - _OpCache_VehicleManageObstacle.insert({param, _OpCache_with_parameter_VehicleManageObstacle}); - } - - } else { - std::unordered_map<Cruise_finite1_deterministic_MC::_ProjectionRead_VehicleManageObstacle, Cruise_finite1_deterministic_MC::_ProjectionWrite_VehicleManageObstacle, Cruise_finite1_deterministic_MC::_ProjectionRead_VehicleManageObstacle::Hash, Cruise_finite1_deterministic_MC::_ProjectionRead_VehicleManageObstacle::HashEqual> _OpCache_with_parameter_VehicleManageObstacle = _OpCache_with_parameter_VehicleManageObstacle_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_VehicleManageObstacle.find(readState); - if(writeState_ptr != _OpCache_with_parameter_VehicleManageObstacle.end()) { - Cruise_finite1_deterministic_MC::_ProjectionWrite_VehicleManageObstacle writeState = writeState_ptr->second; - copiedState._apply_update_for_VehicleManageObstacle(writeState); - } else { - copiedState.VehicleManageObstacle(_tmp_2, _tmp_1); - Cruise_finite1_deterministic_MC::_ProjectionWrite_VehicleManageObstacle writeState = copiedState._update_for_VehicleManageObstacle(); - { - std::unique_lock<std::mutex> _ProjectionRead_VehicleManageObstacle_lock(_ProjectionRead_VehicleManageObstacle_mutex); - _OpCache_with_parameter_VehicleManageObstacle.insert({readState, writeState}); - } + _OpCache_with_parameter_VehicleManageObstacle.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "VehicleManageObstacle"; - result.insert(copiedState); + copiedState.stateAccessedVia = "VehicleManageObstacle"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } @@ -10170,7 +10038,10 @@ class ModelChecker { copiedState.stateAccessedVia = "ObstacleBecomesOld"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } } else { @@ -10179,14 +10050,20 @@ class ModelChecker { copiedState.CruiseBecomesNotAllowed(); copiedState.stateAccessedVia = "CruiseBecomesNotAllowed"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } if(state._tr_CruiseBecomesAllowed()) { Cruise_finite1_deterministic_MC copiedState = state._copy(); copiedState.CruiseBecomesAllowed(); copiedState.stateAccessedVia = "CruiseBecomesAllowed"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<BTuple<BBoolean, BBoolean >> _trid_3 = state._tr_SetCruiseSpeed(); for(const BTuple<BBoolean, BBoolean >& param : _trid_3) { @@ -10197,7 +10074,10 @@ class ModelChecker { copiedState.SetCruiseSpeed(_tmp_2, _tmp_1); copiedState.stateAccessedVia = "SetCruiseSpeed"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<BTuple<BBoolean, BBoolean >> _trid_4 = state._tr_CCInitialisationFinished(); for(const BTuple<BBoolean, BBoolean >& param : _trid_4) { @@ -10208,14 +10088,20 @@ class ModelChecker { copiedState.CCInitialisationFinished(_tmp_2, _tmp_1); copiedState.stateAccessedVia = "CCInitialisationFinished"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } if(state._tr_CCInitialisationDelayFinished()) { Cruise_finite1_deterministic_MC copiedState = state._copy(); copiedState.CCInitialisationDelayFinished(); copiedState.stateAccessedVia = "CCInitialisationDelayFinished"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<BTuple<BBoolean, BBoolean >> _trid_6 = state._tr_CruiseSpeedChangeFinished(); for(const BTuple<BBoolean, BBoolean >& param : _trid_6) { @@ -10226,112 +10112,160 @@ class ModelChecker { copiedState.CruiseSpeedChangeFinished(_tmp_2, _tmp_1); copiedState.stateAccessedVia = "CruiseSpeedChangeFinished"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } if(state._tr_CruiseSpeedChangeDelayFinished()) { Cruise_finite1_deterministic_MC copiedState = state._copy(); copiedState.CruiseSpeedChangeDelayFinished(); copiedState.stateAccessedVia = "CruiseSpeedChangeDelayFinished"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } if(state._tr_CruiseOff()) { Cruise_finite1_deterministic_MC copiedState = state._copy(); copiedState.CruiseOff(); copiedState.stateAccessedVia = "CruiseOff"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } if(state._tr_ExternalForcesBecomesExtreme()) { Cruise_finite1_deterministic_MC copiedState = state._copy(); copiedState.ExternalForcesBecomesExtreme(); copiedState.stateAccessedVia = "ExternalForcesBecomesExtreme"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } if(state._tr_ExternalForcesBecomesNormal()) { Cruise_finite1_deterministic_MC copiedState = state._copy(); copiedState.ExternalForcesBecomesNormal(); copiedState.stateAccessedVia = "ExternalForcesBecomesNormal"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } if(state._tr_VehicleLeavesCruiseSpeed()) { Cruise_finite1_deterministic_MC copiedState = state._copy(); copiedState.VehicleLeavesCruiseSpeed(); copiedState.stateAccessedVia = "VehicleLeavesCruiseSpeed"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } if(state._tr_VehicleReachesCruiseSpeed()) { Cruise_finite1_deterministic_MC copiedState = state._copy(); copiedState.VehicleReachesCruiseSpeed(); copiedState.stateAccessedVia = "VehicleReachesCruiseSpeed"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } if(state._tr_VehicleExceedsMaxCruiseSpeed()) { Cruise_finite1_deterministic_MC copiedState = state._copy(); copiedState.VehicleExceedsMaxCruiseSpeed(); copiedState.stateAccessedVia = "VehicleExceedsMaxCruiseSpeed"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } if(state._tr_VehicleFallsBelowMaxCruiseSpeed()) { Cruise_finite1_deterministic_MC copiedState = state._copy(); copiedState.VehicleFallsBelowMaxCruiseSpeed(); copiedState.stateAccessedVia = "VehicleFallsBelowMaxCruiseSpeed"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } if(state._tr_ObstacleDistanceBecomesVeryClose()) { Cruise_finite1_deterministic_MC copiedState = state._copy(); copiedState.ObstacleDistanceBecomesVeryClose(); copiedState.stateAccessedVia = "ObstacleDistanceBecomesVeryClose"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } if(state._tr_ObstacleDistanceBecomesClose()) { Cruise_finite1_deterministic_MC copiedState = state._copy(); copiedState.ObstacleDistanceBecomesClose(); copiedState.stateAccessedVia = "ObstacleDistanceBecomesClose"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } if(state._tr_ObstacleDistanceBecomesBig()) { Cruise_finite1_deterministic_MC copiedState = state._copy(); copiedState.ObstacleDistanceBecomesBig(); copiedState.stateAccessedVia = "ObstacleDistanceBecomesBig"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } if(state._tr_ObstacleStartsTravelFaster()) { Cruise_finite1_deterministic_MC copiedState = state._copy(); copiedState.ObstacleStartsTravelFaster(); copiedState.stateAccessedVia = "ObstacleStartsTravelFaster"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } if(state._tr_ObstacleStopsTravelFaster()) { Cruise_finite1_deterministic_MC copiedState = state._copy(); copiedState.ObstacleStopsTravelFaster(); copiedState.stateAccessedVia = "ObstacleStopsTravelFaster"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } if(state._tr_ObstacleStartsTravelSlower()) { Cruise_finite1_deterministic_MC copiedState = state._copy(); copiedState.ObstacleStartsTravelSlower(); copiedState.stateAccessedVia = "ObstacleStartsTravelSlower"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } if(state._tr_ObstacleStopsTravelSlower()) { Cruise_finite1_deterministic_MC copiedState = state._copy(); copiedState.ObstacleStopsTravelSlower(); copiedState.stateAccessedVia = "ObstacleStopsTravelSlower"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<BTuple<Cruise_finite1_deterministic_MC::RSset, Cruise_finite1_deterministic_MC::ODset >> _trid_22 = state._tr_ObstacleAppearsWhenCruiseActive(); for(const BTuple<Cruise_finite1_deterministic_MC::RSset, Cruise_finite1_deterministic_MC::ODset >& param : _trid_22) { @@ -10342,7 +10276,10 @@ class ModelChecker { copiedState.ObstacleAppearsWhenCruiseActive(_tmp_2, _tmp_1); copiedState.stateAccessedVia = "ObstacleAppearsWhenCruiseActive"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<Cruise_finite1_deterministic_MC::RSset> _trid_23 = state._tr_ObstacleAppearsWhenCruiseInactive(); for(const Cruise_finite1_deterministic_MC::RSset& param : _trid_23) { @@ -10352,14 +10289,20 @@ class ModelChecker { copiedState.ObstacleAppearsWhenCruiseInactive(_tmp_1); copiedState.stateAccessedVia = "ObstacleAppearsWhenCruiseInactive"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } if(state._tr_ObstacleDisappears()) { Cruise_finite1_deterministic_MC copiedState = state._copy(); copiedState.ObstacleDisappears(); copiedState.stateAccessedVia = "ObstacleDisappears"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<BTuple<BBoolean, BBoolean >> _trid_25 = state._tr_VehicleManageObstacle(); for(const BTuple<BBoolean, BBoolean >& param : _trid_25) { @@ -10370,14 +10313,20 @@ class ModelChecker { copiedState.VehicleManageObstacle(_tmp_2, _tmp_1); copiedState.stateAccessedVia = "VehicleManageObstacle"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } if(state._tr_ObstacleBecomesOld()) { Cruise_finite1_deterministic_MC copiedState = state._copy(); copiedState.ObstacleBecomesOld(); copiedState.stateAccessedVia = "ObstacleBecomesOld"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } } diff --git a/benchmarks/model_checking_opreuse/C++/LandingGear_R6.cpp b/benchmarks/model_checking_opreuse/C++/LandingGear_R6.cpp index b0cdc8b8700cec6d91da4ece888a3b7ce2e8f71d..73b243d7790a45f5a5b2547850640665b69f9c5d 100644 --- a/benchmarks/model_checking_opreuse/C++/LandingGear_R6.cpp +++ b/benchmarks/model_checking_opreuse/C++/LandingGear_R6.cpp @@ -10,7 +10,6 @@ #include <atomic> #include <any> #include <mutex> -#include <shared_mutex> #include <future> #include <boost/asio/post.hpp> #include <boost/asio/thread_pool.hpp> @@ -10473,12 +10472,16 @@ class ModelChecker { states.insert(machine); unvisitedStates.push_back(machine); - std::atomic<bool> stopThreads(false); + std::atomic<bool> stopThreads; + stopThreads = false; std::atomic<int> possibleQueueChanges; possibleQueueChanges = 0; - while(!unvisitedStates.empty() && !stopThreads.load()) { - possibleQueueChanges.fetch_add(1); + std::atomic<bool> waitFlag; + waitFlag = true; + + while(!unvisitedStates.empty() && !stopThreads) { + possibleQueueChanges += 1; LandingGear_R6 state = next(); std::packaged_task<void()> task([&, state] { std::unordered_set<LandingGear_R6, LandingGear_R6::Hash, LandingGear_R6::HashEqual> nextStates = generateNextStates(state); @@ -10499,12 +10502,14 @@ class ModelChecker { } } - possibleQueueChanges.fetch_sub(1); { std::unique_lock<std::mutex> lock(mutex); - if (!unvisitedStates.empty() || possibleQueueChanges.load() == 0) { + possibleQueueChanges -= 1; + int running = possibleQueueChanges; + if (!unvisitedStates.empty() || running == 0) { { std::unique_lock<std::mutex> lock(waitMutex); + waitFlag = false; waitCV.notify_one(); } } @@ -10514,24 +10519,27 @@ class ModelChecker { if(invariantViolated(state)) { invariantViolatedBool = true; counterExampleState = state; - stopThreads.store(true); + stopThreads = true; } if(nextStates.empty()) { deadlockDetected = true; counterExampleState = state; - stopThreads.store(true); + stopThreads = true; } }); + waitFlag = true; boost::asio::post(workers, std::move(task)); { std::unique_lock<std::mutex> lock(waitMutex); - waitCV.wait(lock, [&] { - return !unvisitedStates.empty() || possibleQueueChanges == 0; - }); + if(unvisitedStates.empty() && possibleQueueChanges > 0) { + waitCV.wait(lock, [&] { + return waitFlag == false; + }); + } } } workers.join(); @@ -10620,7 +10628,10 @@ class ModelChecker { copiedState.stateAccessedVia = "begin_flying"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } LandingGear_R6::_ProjectionRead__tr_land_plane read__tr_land_plane_state = state._projected_state_for__tr_land_plane(); bool _trid_2; @@ -10667,7 +10678,10 @@ class ModelChecker { copiedState.stateAccessedVia = "land_plane"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } LandingGear_R6::_ProjectionRead__tr_open_valve_door_open read__tr_open_valve_door_open_state = state._projected_state_for__tr_open_valve_door_open(); bool _trid_3; @@ -10714,7 +10728,10 @@ class ModelChecker { copiedState.stateAccessedVia = "open_valve_door_open"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } LandingGear_R6::_ProjectionRead__tr_close_valve_door_open read__tr_close_valve_door_open_state = state._projected_state_for__tr_close_valve_door_open(); bool _trid_4; @@ -10761,7 +10778,10 @@ class ModelChecker { copiedState.stateAccessedVia = "close_valve_door_open"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } LandingGear_R6::_ProjectionRead__tr_open_valve_door_close read__tr_open_valve_door_close_state = state._projected_state_for__tr_open_valve_door_close(); bool _trid_5; @@ -10808,7 +10828,10 @@ class ModelChecker { copiedState.stateAccessedVia = "open_valve_door_close"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } LandingGear_R6::_ProjectionRead__tr_close_valve_door_close read__tr_close_valve_door_close_state = state._projected_state_for__tr_close_valve_door_close(); bool _trid_6; @@ -10855,7 +10878,10 @@ class ModelChecker { copiedState.stateAccessedVia = "close_valve_door_close"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } LandingGear_R6::_ProjectionRead__tr_open_valve_retract_gear read__tr_open_valve_retract_gear_state = state._projected_state_for__tr_open_valve_retract_gear(); bool _trid_7; @@ -10902,7 +10928,10 @@ class ModelChecker { copiedState.stateAccessedVia = "open_valve_retract_gear"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } LandingGear_R6::_ProjectionRead__tr_close_valve_retract_gear read__tr_close_valve_retract_gear_state = state._projected_state_for__tr_close_valve_retract_gear(); bool _trid_8; @@ -10949,7 +10978,10 @@ class ModelChecker { copiedState.stateAccessedVia = "close_valve_retract_gear"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } LandingGear_R6::_ProjectionRead__tr_open_valve_extend_gear read__tr_open_valve_extend_gear_state = state._projected_state_for__tr_open_valve_extend_gear(); bool _trid_9; @@ -10996,7 +11028,10 @@ class ModelChecker { copiedState.stateAccessedVia = "open_valve_extend_gear"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } LandingGear_R6::_ProjectionRead__tr_close_valve_extend_gear read__tr_close_valve_extend_gear_state = state._projected_state_for__tr_close_valve_extend_gear(); bool _trid_10; @@ -11043,7 +11078,10 @@ class ModelChecker { copiedState.stateAccessedVia = "close_valve_extend_gear"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } LandingGear_R6::_ProjectionRead__tr_con_stimulate_open_door_valve read__tr_con_stimulate_open_door_valve_state = state._projected_state_for__tr_con_stimulate_open_door_valve(); bool _trid_11; @@ -11090,7 +11128,10 @@ class ModelChecker { copiedState.stateAccessedVia = "con_stimulate_open_door_valve"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } LandingGear_R6::_ProjectionRead__tr_con_stop_stimulate_open_door_valve read__tr_con_stop_stimulate_open_door_valve_state = state._projected_state_for__tr_con_stop_stimulate_open_door_valve(); bool _trid_12; @@ -11137,7 +11178,10 @@ class ModelChecker { copiedState.stateAccessedVia = "con_stop_stimulate_open_door_valve"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } LandingGear_R6::_ProjectionRead__tr_con_stimulate_close_door_valve read__tr_con_stimulate_close_door_valve_state = state._projected_state_for__tr_con_stimulate_close_door_valve(); bool _trid_13; @@ -11184,7 +11228,10 @@ class ModelChecker { copiedState.stateAccessedVia = "con_stimulate_close_door_valve"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } LandingGear_R6::_ProjectionRead__tr_con_stop_stimulate_close_door_valve read__tr_con_stop_stimulate_close_door_valve_state = state._projected_state_for__tr_con_stop_stimulate_close_door_valve(); bool _trid_14; @@ -11231,7 +11278,10 @@ class ModelChecker { copiedState.stateAccessedVia = "con_stop_stimulate_close_door_valve"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } LandingGear_R6::_ProjectionRead__tr_con_stimulate_retract_gear_valve read__tr_con_stimulate_retract_gear_valve_state = state._projected_state_for__tr_con_stimulate_retract_gear_valve(); bool _trid_15; @@ -11278,7 +11328,10 @@ class ModelChecker { copiedState.stateAccessedVia = "con_stimulate_retract_gear_valve"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } LandingGear_R6::_ProjectionRead__tr_con_stop_stimulate_retract_gear_valve read__tr_con_stop_stimulate_retract_gear_valve_state = state._projected_state_for__tr_con_stop_stimulate_retract_gear_valve(); bool _trid_16; @@ -11325,7 +11378,10 @@ class ModelChecker { copiedState.stateAccessedVia = "con_stop_stimulate_retract_gear_valve"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } LandingGear_R6::_ProjectionRead__tr_con_stimulate_extend_gear_valve read__tr_con_stimulate_extend_gear_valve_state = state._projected_state_for__tr_con_stimulate_extend_gear_valve(); bool _trid_17; @@ -11372,7 +11428,10 @@ class ModelChecker { copiedState.stateAccessedVia = "con_stimulate_extend_gear_valve"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } LandingGear_R6::_ProjectionRead__tr_con_stop_stimulate_extend_gear_valve read__tr_con_stop_stimulate_extend_gear_valve_state = state._projected_state_for__tr_con_stop_stimulate_extend_gear_valve(); bool _trid_18; @@ -11419,1025 +11478,644 @@ class ModelChecker { copiedState.stateAccessedVia = "con_stop_stimulate_extend_gear_valve"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } LandingGear_R6::_ProjectionRead__tr_env_start_retracting_first read__tr_env_start_retracting_first_state = state._projected_state_for__tr_env_start_retracting_first(); + BSet<LandingGear_R6::POSITION> _trid_19; auto _trid_19_ptr = _OpCache_tr_env_start_retracting_first.find(read__tr_env_start_retracting_first_state); if(_trid_19_ptr == _OpCache_tr_env_start_retracting_first.end()) { - BSet<LandingGear_R6::POSITION> _trid_19 = state._tr_env_start_retracting_first(); + _trid_19 = state._tr_env_start_retracting_first(); { std::unique_lock<std::mutex> _ProjectionRead__tr_env_start_retracting_first_lock(_ProjectionRead__tr_env_start_retracting_first_mutex); _OpCache_tr_env_start_retracting_first.insert({read__tr_env_start_retracting_first_state, _trid_19}); } - for(const LandingGear_R6::POSITION& param : _trid_19) { - LandingGear_R6::POSITION _tmp_1 = param; - - LandingGear_R6 copiedState = state._copy(); - LandingGear_R6::_ProjectionRead_env_start_retracting_first readState = state._projected_state_for_env_start_retracting_first(); + } else { + _trid_19 = _trid_19_ptr->second; + } - auto _OpCache_with_parameter_env_start_retracting_first_ptr = _OpCache_env_start_retracting_first.find(param); - if(_OpCache_with_parameter_env_start_retracting_first_ptr == _OpCache_env_start_retracting_first.end()) { - copiedState.env_start_retracting_first(_tmp_1); - LandingGear_R6::_ProjectionWrite_env_start_retracting_first writeState = copiedState._update_for_env_start_retracting_first(); - std::unordered_map<LandingGear_R6::_ProjectionRead_env_start_retracting_first, LandingGear_R6::_ProjectionWrite_env_start_retracting_first, LandingGear_R6::_ProjectionRead_env_start_retracting_first::Hash, LandingGear_R6::_ProjectionRead_env_start_retracting_first::HashEqual> _OpCache_with_parameter_env_start_retracting_first; - _OpCache_with_parameter_env_start_retracting_first.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_env_start_retracting_first_lock(_ProjectionRead_env_start_retracting_first_mutex); - _OpCache_env_start_retracting_first.insert({param, _OpCache_with_parameter_env_start_retracting_first}); - } + for(const LandingGear_R6::POSITION& param : _trid_19) { + LandingGear_R6::POSITION _tmp_1 = param; - } else { - std::unordered_map<LandingGear_R6::_ProjectionRead_env_start_retracting_first, LandingGear_R6::_ProjectionWrite_env_start_retracting_first, LandingGear_R6::_ProjectionRead_env_start_retracting_first::Hash, LandingGear_R6::_ProjectionRead_env_start_retracting_first::HashEqual> _OpCache_with_parameter_env_start_retracting_first = _OpCache_with_parameter_env_start_retracting_first_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_env_start_retracting_first.find(readState); - if(writeState_ptr != _OpCache_with_parameter_env_start_retracting_first.end()) { - LandingGear_R6::_ProjectionWrite_env_start_retracting_first writeState = writeState_ptr->second; - copiedState._apply_update_for_env_start_retracting_first(writeState); - } else { - copiedState.env_start_retracting_first(_tmp_1); - LandingGear_R6::_ProjectionWrite_env_start_retracting_first writeState = copiedState._update_for_env_start_retracting_first(); - { - std::unique_lock<std::mutex> _ProjectionRead_env_start_retracting_first_lock(_ProjectionRead_env_start_retracting_first_mutex); - _OpCache_with_parameter_env_start_retracting_first.insert({readState, writeState}); - } - } + LandingGear_R6 copiedState = state._copy(); + LandingGear_R6::_ProjectionRead_env_start_retracting_first readState = state._projected_state_for_env_start_retracting_first(); + + auto _OpCache_with_parameter_env_start_retracting_first_ptr = _OpCache_env_start_retracting_first.find(param); + if(_OpCache_with_parameter_env_start_retracting_first_ptr == _OpCache_env_start_retracting_first.end()) { + copiedState.env_start_retracting_first(_tmp_1); + LandingGear_R6::_ProjectionWrite_env_start_retracting_first writeState = copiedState._update_for_env_start_retracting_first(); + std::unordered_map<LandingGear_R6::_ProjectionRead_env_start_retracting_first, LandingGear_R6::_ProjectionWrite_env_start_retracting_first, LandingGear_R6::_ProjectionRead_env_start_retracting_first::Hash, LandingGear_R6::_ProjectionRead_env_start_retracting_first::HashEqual> _OpCache_with_parameter_env_start_retracting_first; + _OpCache_with_parameter_env_start_retracting_first.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_env_start_retracting_first_lock(_ProjectionRead_env_start_retracting_first_mutex); + _OpCache_env_start_retracting_first.insert({param, _OpCache_with_parameter_env_start_retracting_first}); } - copiedState.stateAccessedVia = "env_start_retracting_first"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<LandingGear_R6::POSITION> _trid_19 = _trid_19_ptr->second; - for(const LandingGear_R6::POSITION& param : _trid_19) { - LandingGear_R6::POSITION _tmp_1 = param; - - LandingGear_R6 copiedState = state._copy(); - LandingGear_R6::_ProjectionRead_env_start_retracting_first readState = state._projected_state_for_env_start_retracting_first(); - - auto _OpCache_with_parameter_env_start_retracting_first_ptr = _OpCache_env_start_retracting_first.find(param); - if(_OpCache_with_parameter_env_start_retracting_first_ptr == _OpCache_env_start_retracting_first.end()) { + } else { + std::unordered_map<LandingGear_R6::_ProjectionRead_env_start_retracting_first, LandingGear_R6::_ProjectionWrite_env_start_retracting_first, LandingGear_R6::_ProjectionRead_env_start_retracting_first::Hash, LandingGear_R6::_ProjectionRead_env_start_retracting_first::HashEqual> _OpCache_with_parameter_env_start_retracting_first = _OpCache_with_parameter_env_start_retracting_first_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_env_start_retracting_first.find(readState); + if(writeState_ptr != _OpCache_with_parameter_env_start_retracting_first.end()) { + LandingGear_R6::_ProjectionWrite_env_start_retracting_first writeState = writeState_ptr->second; + copiedState._apply_update_for_env_start_retracting_first(writeState); + } else { copiedState.env_start_retracting_first(_tmp_1); LandingGear_R6::_ProjectionWrite_env_start_retracting_first writeState = copiedState._update_for_env_start_retracting_first(); - std::unordered_map<LandingGear_R6::_ProjectionRead_env_start_retracting_first, LandingGear_R6::_ProjectionWrite_env_start_retracting_first, LandingGear_R6::_ProjectionRead_env_start_retracting_first::Hash, LandingGear_R6::_ProjectionRead_env_start_retracting_first::HashEqual> _OpCache_with_parameter_env_start_retracting_first; - _OpCache_with_parameter_env_start_retracting_first.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_env_start_retracting_first_lock(_ProjectionRead_env_start_retracting_first_mutex); - _OpCache_env_start_retracting_first.insert({param, _OpCache_with_parameter_env_start_retracting_first}); - } - - } else { - std::unordered_map<LandingGear_R6::_ProjectionRead_env_start_retracting_first, LandingGear_R6::_ProjectionWrite_env_start_retracting_first, LandingGear_R6::_ProjectionRead_env_start_retracting_first::Hash, LandingGear_R6::_ProjectionRead_env_start_retracting_first::HashEqual> _OpCache_with_parameter_env_start_retracting_first = _OpCache_with_parameter_env_start_retracting_first_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_env_start_retracting_first.find(readState); - if(writeState_ptr != _OpCache_with_parameter_env_start_retracting_first.end()) { - LandingGear_R6::_ProjectionWrite_env_start_retracting_first writeState = writeState_ptr->second; - copiedState._apply_update_for_env_start_retracting_first(writeState); - } else { - copiedState.env_start_retracting_first(_tmp_1); - LandingGear_R6::_ProjectionWrite_env_start_retracting_first writeState = copiedState._update_for_env_start_retracting_first(); - { - std::unique_lock<std::mutex> _ProjectionRead_env_start_retracting_first_lock(_ProjectionRead_env_start_retracting_first_mutex); - _OpCache_with_parameter_env_start_retracting_first.insert({readState, writeState}); - } + _OpCache_with_parameter_env_start_retracting_first.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "env_start_retracting_first"; - result.insert(copiedState); + copiedState.stateAccessedVia = "env_start_retracting_first"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } LandingGear_R6::_ProjectionRead__tr_env_retract_gear_skip read__tr_env_retract_gear_skip_state = state._projected_state_for__tr_env_retract_gear_skip(); + BSet<LandingGear_R6::POSITION> _trid_20; auto _trid_20_ptr = _OpCache_tr_env_retract_gear_skip.find(read__tr_env_retract_gear_skip_state); if(_trid_20_ptr == _OpCache_tr_env_retract_gear_skip.end()) { - BSet<LandingGear_R6::POSITION> _trid_20 = state._tr_env_retract_gear_skip(); + _trid_20 = state._tr_env_retract_gear_skip(); { std::unique_lock<std::mutex> _ProjectionRead__tr_env_retract_gear_skip_lock(_ProjectionRead__tr_env_retract_gear_skip_mutex); _OpCache_tr_env_retract_gear_skip.insert({read__tr_env_retract_gear_skip_state, _trid_20}); } - for(const LandingGear_R6::POSITION& param : _trid_20) { - LandingGear_R6::POSITION _tmp_1 = param; - - LandingGear_R6 copiedState = state._copy(); - LandingGear_R6::_ProjectionRead_env_retract_gear_skip readState = state._projected_state_for_env_retract_gear_skip(); + } else { + _trid_20 = _trid_20_ptr->second; + } - auto _OpCache_with_parameter_env_retract_gear_skip_ptr = _OpCache_env_retract_gear_skip.find(param); - if(_OpCache_with_parameter_env_retract_gear_skip_ptr == _OpCache_env_retract_gear_skip.end()) { - copiedState.env_retract_gear_skip(_tmp_1); - LandingGear_R6::_ProjectionWrite_env_retract_gear_skip writeState = copiedState._update_for_env_retract_gear_skip(); - std::unordered_map<LandingGear_R6::_ProjectionRead_env_retract_gear_skip, LandingGear_R6::_ProjectionWrite_env_retract_gear_skip, LandingGear_R6::_ProjectionRead_env_retract_gear_skip::Hash, LandingGear_R6::_ProjectionRead_env_retract_gear_skip::HashEqual> _OpCache_with_parameter_env_retract_gear_skip; - _OpCache_with_parameter_env_retract_gear_skip.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_env_retract_gear_skip_lock(_ProjectionRead_env_retract_gear_skip_mutex); - _OpCache_env_retract_gear_skip.insert({param, _OpCache_with_parameter_env_retract_gear_skip}); - } + for(const LandingGear_R6::POSITION& param : _trid_20) { + LandingGear_R6::POSITION _tmp_1 = param; - } else { - std::unordered_map<LandingGear_R6::_ProjectionRead_env_retract_gear_skip, LandingGear_R6::_ProjectionWrite_env_retract_gear_skip, LandingGear_R6::_ProjectionRead_env_retract_gear_skip::Hash, LandingGear_R6::_ProjectionRead_env_retract_gear_skip::HashEqual> _OpCache_with_parameter_env_retract_gear_skip = _OpCache_with_parameter_env_retract_gear_skip_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_env_retract_gear_skip.find(readState); - if(writeState_ptr != _OpCache_with_parameter_env_retract_gear_skip.end()) { - LandingGear_R6::_ProjectionWrite_env_retract_gear_skip writeState = writeState_ptr->second; - copiedState._apply_update_for_env_retract_gear_skip(writeState); - } else { - copiedState.env_retract_gear_skip(_tmp_1); - LandingGear_R6::_ProjectionWrite_env_retract_gear_skip writeState = copiedState._update_for_env_retract_gear_skip(); - { - std::unique_lock<std::mutex> _ProjectionRead_env_retract_gear_skip_lock(_ProjectionRead_env_retract_gear_skip_mutex); - _OpCache_with_parameter_env_retract_gear_skip.insert({readState, writeState}); - } - } + LandingGear_R6 copiedState = state._copy(); + LandingGear_R6::_ProjectionRead_env_retract_gear_skip readState = state._projected_state_for_env_retract_gear_skip(); + + auto _OpCache_with_parameter_env_retract_gear_skip_ptr = _OpCache_env_retract_gear_skip.find(param); + if(_OpCache_with_parameter_env_retract_gear_skip_ptr == _OpCache_env_retract_gear_skip.end()) { + copiedState.env_retract_gear_skip(_tmp_1); + LandingGear_R6::_ProjectionWrite_env_retract_gear_skip writeState = copiedState._update_for_env_retract_gear_skip(); + std::unordered_map<LandingGear_R6::_ProjectionRead_env_retract_gear_skip, LandingGear_R6::_ProjectionWrite_env_retract_gear_skip, LandingGear_R6::_ProjectionRead_env_retract_gear_skip::Hash, LandingGear_R6::_ProjectionRead_env_retract_gear_skip::HashEqual> _OpCache_with_parameter_env_retract_gear_skip; + _OpCache_with_parameter_env_retract_gear_skip.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_env_retract_gear_skip_lock(_ProjectionRead_env_retract_gear_skip_mutex); + _OpCache_env_retract_gear_skip.insert({param, _OpCache_with_parameter_env_retract_gear_skip}); } - copiedState.stateAccessedVia = "env_retract_gear_skip"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<LandingGear_R6::POSITION> _trid_20 = _trid_20_ptr->second; - for(const LandingGear_R6::POSITION& param : _trid_20) { - LandingGear_R6::POSITION _tmp_1 = param; - - LandingGear_R6 copiedState = state._copy(); - LandingGear_R6::_ProjectionRead_env_retract_gear_skip readState = state._projected_state_for_env_retract_gear_skip(); - - auto _OpCache_with_parameter_env_retract_gear_skip_ptr = _OpCache_env_retract_gear_skip.find(param); - if(_OpCache_with_parameter_env_retract_gear_skip_ptr == _OpCache_env_retract_gear_skip.end()) { + } else { + std::unordered_map<LandingGear_R6::_ProjectionRead_env_retract_gear_skip, LandingGear_R6::_ProjectionWrite_env_retract_gear_skip, LandingGear_R6::_ProjectionRead_env_retract_gear_skip::Hash, LandingGear_R6::_ProjectionRead_env_retract_gear_skip::HashEqual> _OpCache_with_parameter_env_retract_gear_skip = _OpCache_with_parameter_env_retract_gear_skip_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_env_retract_gear_skip.find(readState); + if(writeState_ptr != _OpCache_with_parameter_env_retract_gear_skip.end()) { + LandingGear_R6::_ProjectionWrite_env_retract_gear_skip writeState = writeState_ptr->second; + copiedState._apply_update_for_env_retract_gear_skip(writeState); + } else { copiedState.env_retract_gear_skip(_tmp_1); LandingGear_R6::_ProjectionWrite_env_retract_gear_skip writeState = copiedState._update_for_env_retract_gear_skip(); - std::unordered_map<LandingGear_R6::_ProjectionRead_env_retract_gear_skip, LandingGear_R6::_ProjectionWrite_env_retract_gear_skip, LandingGear_R6::_ProjectionRead_env_retract_gear_skip::Hash, LandingGear_R6::_ProjectionRead_env_retract_gear_skip::HashEqual> _OpCache_with_parameter_env_retract_gear_skip; - _OpCache_with_parameter_env_retract_gear_skip.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_env_retract_gear_skip_lock(_ProjectionRead_env_retract_gear_skip_mutex); - _OpCache_env_retract_gear_skip.insert({param, _OpCache_with_parameter_env_retract_gear_skip}); - } - - } else { - std::unordered_map<LandingGear_R6::_ProjectionRead_env_retract_gear_skip, LandingGear_R6::_ProjectionWrite_env_retract_gear_skip, LandingGear_R6::_ProjectionRead_env_retract_gear_skip::Hash, LandingGear_R6::_ProjectionRead_env_retract_gear_skip::HashEqual> _OpCache_with_parameter_env_retract_gear_skip = _OpCache_with_parameter_env_retract_gear_skip_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_env_retract_gear_skip.find(readState); - if(writeState_ptr != _OpCache_with_parameter_env_retract_gear_skip.end()) { - LandingGear_R6::_ProjectionWrite_env_retract_gear_skip writeState = writeState_ptr->second; - copiedState._apply_update_for_env_retract_gear_skip(writeState); - } else { - copiedState.env_retract_gear_skip(_tmp_1); - LandingGear_R6::_ProjectionWrite_env_retract_gear_skip writeState = copiedState._update_for_env_retract_gear_skip(); - { - std::unique_lock<std::mutex> _ProjectionRead_env_retract_gear_skip_lock(_ProjectionRead_env_retract_gear_skip_mutex); - _OpCache_with_parameter_env_retract_gear_skip.insert({readState, writeState}); - } + _OpCache_with_parameter_env_retract_gear_skip.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "env_retract_gear_skip"; - result.insert(copiedState); + copiedState.stateAccessedVia = "env_retract_gear_skip"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } LandingGear_R6::_ProjectionRead__tr_env_retract_gear_last read__tr_env_retract_gear_last_state = state._projected_state_for__tr_env_retract_gear_last(); + BSet<LandingGear_R6::POSITION> _trid_21; auto _trid_21_ptr = _OpCache_tr_env_retract_gear_last.find(read__tr_env_retract_gear_last_state); if(_trid_21_ptr == _OpCache_tr_env_retract_gear_last.end()) { - BSet<LandingGear_R6::POSITION> _trid_21 = state._tr_env_retract_gear_last(); + _trid_21 = state._tr_env_retract_gear_last(); { std::unique_lock<std::mutex> _ProjectionRead__tr_env_retract_gear_last_lock(_ProjectionRead__tr_env_retract_gear_last_mutex); _OpCache_tr_env_retract_gear_last.insert({read__tr_env_retract_gear_last_state, _trid_21}); } - for(const LandingGear_R6::POSITION& param : _trid_21) { - LandingGear_R6::POSITION _tmp_1 = param; - - LandingGear_R6 copiedState = state._copy(); - LandingGear_R6::_ProjectionRead_env_retract_gear_last readState = state._projected_state_for_env_retract_gear_last(); + } else { + _trid_21 = _trid_21_ptr->second; + } - auto _OpCache_with_parameter_env_retract_gear_last_ptr = _OpCache_env_retract_gear_last.find(param); - if(_OpCache_with_parameter_env_retract_gear_last_ptr == _OpCache_env_retract_gear_last.end()) { - copiedState.env_retract_gear_last(_tmp_1); - LandingGear_R6::_ProjectionWrite_env_retract_gear_last writeState = copiedState._update_for_env_retract_gear_last(); - std::unordered_map<LandingGear_R6::_ProjectionRead_env_retract_gear_last, LandingGear_R6::_ProjectionWrite_env_retract_gear_last, LandingGear_R6::_ProjectionRead_env_retract_gear_last::Hash, LandingGear_R6::_ProjectionRead_env_retract_gear_last::HashEqual> _OpCache_with_parameter_env_retract_gear_last; - _OpCache_with_parameter_env_retract_gear_last.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_env_retract_gear_last_lock(_ProjectionRead_env_retract_gear_last_mutex); - _OpCache_env_retract_gear_last.insert({param, _OpCache_with_parameter_env_retract_gear_last}); - } + for(const LandingGear_R6::POSITION& param : _trid_21) { + LandingGear_R6::POSITION _tmp_1 = param; - } else { - std::unordered_map<LandingGear_R6::_ProjectionRead_env_retract_gear_last, LandingGear_R6::_ProjectionWrite_env_retract_gear_last, LandingGear_R6::_ProjectionRead_env_retract_gear_last::Hash, LandingGear_R6::_ProjectionRead_env_retract_gear_last::HashEqual> _OpCache_with_parameter_env_retract_gear_last = _OpCache_with_parameter_env_retract_gear_last_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_env_retract_gear_last.find(readState); - if(writeState_ptr != _OpCache_with_parameter_env_retract_gear_last.end()) { - LandingGear_R6::_ProjectionWrite_env_retract_gear_last writeState = writeState_ptr->second; - copiedState._apply_update_for_env_retract_gear_last(writeState); - } else { - copiedState.env_retract_gear_last(_tmp_1); - LandingGear_R6::_ProjectionWrite_env_retract_gear_last writeState = copiedState._update_for_env_retract_gear_last(); - { - std::unique_lock<std::mutex> _ProjectionRead_env_retract_gear_last_lock(_ProjectionRead_env_retract_gear_last_mutex); - _OpCache_with_parameter_env_retract_gear_last.insert({readState, writeState}); - } - } + LandingGear_R6 copiedState = state._copy(); + LandingGear_R6::_ProjectionRead_env_retract_gear_last readState = state._projected_state_for_env_retract_gear_last(); + + auto _OpCache_with_parameter_env_retract_gear_last_ptr = _OpCache_env_retract_gear_last.find(param); + if(_OpCache_with_parameter_env_retract_gear_last_ptr == _OpCache_env_retract_gear_last.end()) { + copiedState.env_retract_gear_last(_tmp_1); + LandingGear_R6::_ProjectionWrite_env_retract_gear_last writeState = copiedState._update_for_env_retract_gear_last(); + std::unordered_map<LandingGear_R6::_ProjectionRead_env_retract_gear_last, LandingGear_R6::_ProjectionWrite_env_retract_gear_last, LandingGear_R6::_ProjectionRead_env_retract_gear_last::Hash, LandingGear_R6::_ProjectionRead_env_retract_gear_last::HashEqual> _OpCache_with_parameter_env_retract_gear_last; + _OpCache_with_parameter_env_retract_gear_last.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_env_retract_gear_last_lock(_ProjectionRead_env_retract_gear_last_mutex); + _OpCache_env_retract_gear_last.insert({param, _OpCache_with_parameter_env_retract_gear_last}); } - copiedState.stateAccessedVia = "env_retract_gear_last"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<LandingGear_R6::POSITION> _trid_21 = _trid_21_ptr->second; - for(const LandingGear_R6::POSITION& param : _trid_21) { - LandingGear_R6::POSITION _tmp_1 = param; - - LandingGear_R6 copiedState = state._copy(); - LandingGear_R6::_ProjectionRead_env_retract_gear_last readState = state._projected_state_for_env_retract_gear_last(); - - auto _OpCache_with_parameter_env_retract_gear_last_ptr = _OpCache_env_retract_gear_last.find(param); - if(_OpCache_with_parameter_env_retract_gear_last_ptr == _OpCache_env_retract_gear_last.end()) { + } else { + std::unordered_map<LandingGear_R6::_ProjectionRead_env_retract_gear_last, LandingGear_R6::_ProjectionWrite_env_retract_gear_last, LandingGear_R6::_ProjectionRead_env_retract_gear_last::Hash, LandingGear_R6::_ProjectionRead_env_retract_gear_last::HashEqual> _OpCache_with_parameter_env_retract_gear_last = _OpCache_with_parameter_env_retract_gear_last_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_env_retract_gear_last.find(readState); + if(writeState_ptr != _OpCache_with_parameter_env_retract_gear_last.end()) { + LandingGear_R6::_ProjectionWrite_env_retract_gear_last writeState = writeState_ptr->second; + copiedState._apply_update_for_env_retract_gear_last(writeState); + } else { copiedState.env_retract_gear_last(_tmp_1); LandingGear_R6::_ProjectionWrite_env_retract_gear_last writeState = copiedState._update_for_env_retract_gear_last(); - std::unordered_map<LandingGear_R6::_ProjectionRead_env_retract_gear_last, LandingGear_R6::_ProjectionWrite_env_retract_gear_last, LandingGear_R6::_ProjectionRead_env_retract_gear_last::Hash, LandingGear_R6::_ProjectionRead_env_retract_gear_last::HashEqual> _OpCache_with_parameter_env_retract_gear_last; - _OpCache_with_parameter_env_retract_gear_last.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_env_retract_gear_last_lock(_ProjectionRead_env_retract_gear_last_mutex); - _OpCache_env_retract_gear_last.insert({param, _OpCache_with_parameter_env_retract_gear_last}); - } - - } else { - std::unordered_map<LandingGear_R6::_ProjectionRead_env_retract_gear_last, LandingGear_R6::_ProjectionWrite_env_retract_gear_last, LandingGear_R6::_ProjectionRead_env_retract_gear_last::Hash, LandingGear_R6::_ProjectionRead_env_retract_gear_last::HashEqual> _OpCache_with_parameter_env_retract_gear_last = _OpCache_with_parameter_env_retract_gear_last_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_env_retract_gear_last.find(readState); - if(writeState_ptr != _OpCache_with_parameter_env_retract_gear_last.end()) { - LandingGear_R6::_ProjectionWrite_env_retract_gear_last writeState = writeState_ptr->second; - copiedState._apply_update_for_env_retract_gear_last(writeState); - } else { - copiedState.env_retract_gear_last(_tmp_1); - LandingGear_R6::_ProjectionWrite_env_retract_gear_last writeState = copiedState._update_for_env_retract_gear_last(); - { - std::unique_lock<std::mutex> _ProjectionRead_env_retract_gear_last_lock(_ProjectionRead_env_retract_gear_last_mutex); - _OpCache_with_parameter_env_retract_gear_last.insert({readState, writeState}); - } + _OpCache_with_parameter_env_retract_gear_last.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "env_retract_gear_last"; - result.insert(copiedState); + copiedState.stateAccessedVia = "env_retract_gear_last"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } LandingGear_R6::_ProjectionRead__tr_env_start_extending read__tr_env_start_extending_state = state._projected_state_for__tr_env_start_extending(); + BSet<LandingGear_R6::POSITION> _trid_22; auto _trid_22_ptr = _OpCache_tr_env_start_extending.find(read__tr_env_start_extending_state); if(_trid_22_ptr == _OpCache_tr_env_start_extending.end()) { - BSet<LandingGear_R6::POSITION> _trid_22 = state._tr_env_start_extending(); + _trid_22 = state._tr_env_start_extending(); { std::unique_lock<std::mutex> _ProjectionRead__tr_env_start_extending_lock(_ProjectionRead__tr_env_start_extending_mutex); _OpCache_tr_env_start_extending.insert({read__tr_env_start_extending_state, _trid_22}); } - for(const LandingGear_R6::POSITION& param : _trid_22) { - LandingGear_R6::POSITION _tmp_1 = param; - - LandingGear_R6 copiedState = state._copy(); - LandingGear_R6::_ProjectionRead_env_start_extending readState = state._projected_state_for_env_start_extending(); + } else { + _trid_22 = _trid_22_ptr->second; + } - auto _OpCache_with_parameter_env_start_extending_ptr = _OpCache_env_start_extending.find(param); - if(_OpCache_with_parameter_env_start_extending_ptr == _OpCache_env_start_extending.end()) { - copiedState.env_start_extending(_tmp_1); - LandingGear_R6::_ProjectionWrite_env_start_extending writeState = copiedState._update_for_env_start_extending(); - std::unordered_map<LandingGear_R6::_ProjectionRead_env_start_extending, LandingGear_R6::_ProjectionWrite_env_start_extending, LandingGear_R6::_ProjectionRead_env_start_extending::Hash, LandingGear_R6::_ProjectionRead_env_start_extending::HashEqual> _OpCache_with_parameter_env_start_extending; - _OpCache_with_parameter_env_start_extending.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_env_start_extending_lock(_ProjectionRead_env_start_extending_mutex); - _OpCache_env_start_extending.insert({param, _OpCache_with_parameter_env_start_extending}); - } + for(const LandingGear_R6::POSITION& param : _trid_22) { + LandingGear_R6::POSITION _tmp_1 = param; - } else { - std::unordered_map<LandingGear_R6::_ProjectionRead_env_start_extending, LandingGear_R6::_ProjectionWrite_env_start_extending, LandingGear_R6::_ProjectionRead_env_start_extending::Hash, LandingGear_R6::_ProjectionRead_env_start_extending::HashEqual> _OpCache_with_parameter_env_start_extending = _OpCache_with_parameter_env_start_extending_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_env_start_extending.find(readState); - if(writeState_ptr != _OpCache_with_parameter_env_start_extending.end()) { - LandingGear_R6::_ProjectionWrite_env_start_extending writeState = writeState_ptr->second; - copiedState._apply_update_for_env_start_extending(writeState); - } else { - copiedState.env_start_extending(_tmp_1); - LandingGear_R6::_ProjectionWrite_env_start_extending writeState = copiedState._update_for_env_start_extending(); - { - std::unique_lock<std::mutex> _ProjectionRead_env_start_extending_lock(_ProjectionRead_env_start_extending_mutex); - _OpCache_with_parameter_env_start_extending.insert({readState, writeState}); - } - } + LandingGear_R6 copiedState = state._copy(); + LandingGear_R6::_ProjectionRead_env_start_extending readState = state._projected_state_for_env_start_extending(); + + auto _OpCache_with_parameter_env_start_extending_ptr = _OpCache_env_start_extending.find(param); + if(_OpCache_with_parameter_env_start_extending_ptr == _OpCache_env_start_extending.end()) { + copiedState.env_start_extending(_tmp_1); + LandingGear_R6::_ProjectionWrite_env_start_extending writeState = copiedState._update_for_env_start_extending(); + std::unordered_map<LandingGear_R6::_ProjectionRead_env_start_extending, LandingGear_R6::_ProjectionWrite_env_start_extending, LandingGear_R6::_ProjectionRead_env_start_extending::Hash, LandingGear_R6::_ProjectionRead_env_start_extending::HashEqual> _OpCache_with_parameter_env_start_extending; + _OpCache_with_parameter_env_start_extending.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_env_start_extending_lock(_ProjectionRead_env_start_extending_mutex); + _OpCache_env_start_extending.insert({param, _OpCache_with_parameter_env_start_extending}); } - copiedState.stateAccessedVia = "env_start_extending"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<LandingGear_R6::POSITION> _trid_22 = _trid_22_ptr->second; - for(const LandingGear_R6::POSITION& param : _trid_22) { - LandingGear_R6::POSITION _tmp_1 = param; - - LandingGear_R6 copiedState = state._copy(); - LandingGear_R6::_ProjectionRead_env_start_extending readState = state._projected_state_for_env_start_extending(); - - auto _OpCache_with_parameter_env_start_extending_ptr = _OpCache_env_start_extending.find(param); - if(_OpCache_with_parameter_env_start_extending_ptr == _OpCache_env_start_extending.end()) { + } else { + std::unordered_map<LandingGear_R6::_ProjectionRead_env_start_extending, LandingGear_R6::_ProjectionWrite_env_start_extending, LandingGear_R6::_ProjectionRead_env_start_extending::Hash, LandingGear_R6::_ProjectionRead_env_start_extending::HashEqual> _OpCache_with_parameter_env_start_extending = _OpCache_with_parameter_env_start_extending_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_env_start_extending.find(readState); + if(writeState_ptr != _OpCache_with_parameter_env_start_extending.end()) { + LandingGear_R6::_ProjectionWrite_env_start_extending writeState = writeState_ptr->second; + copiedState._apply_update_for_env_start_extending(writeState); + } else { copiedState.env_start_extending(_tmp_1); LandingGear_R6::_ProjectionWrite_env_start_extending writeState = copiedState._update_for_env_start_extending(); - std::unordered_map<LandingGear_R6::_ProjectionRead_env_start_extending, LandingGear_R6::_ProjectionWrite_env_start_extending, LandingGear_R6::_ProjectionRead_env_start_extending::Hash, LandingGear_R6::_ProjectionRead_env_start_extending::HashEqual> _OpCache_with_parameter_env_start_extending; - _OpCache_with_parameter_env_start_extending.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_env_start_extending_lock(_ProjectionRead_env_start_extending_mutex); - _OpCache_env_start_extending.insert({param, _OpCache_with_parameter_env_start_extending}); - } - - } else { - std::unordered_map<LandingGear_R6::_ProjectionRead_env_start_extending, LandingGear_R6::_ProjectionWrite_env_start_extending, LandingGear_R6::_ProjectionRead_env_start_extending::Hash, LandingGear_R6::_ProjectionRead_env_start_extending::HashEqual> _OpCache_with_parameter_env_start_extending = _OpCache_with_parameter_env_start_extending_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_env_start_extending.find(readState); - if(writeState_ptr != _OpCache_with_parameter_env_start_extending.end()) { - LandingGear_R6::_ProjectionWrite_env_start_extending writeState = writeState_ptr->second; - copiedState._apply_update_for_env_start_extending(writeState); - } else { - copiedState.env_start_extending(_tmp_1); - LandingGear_R6::_ProjectionWrite_env_start_extending writeState = copiedState._update_for_env_start_extending(); - { - std::unique_lock<std::mutex> _ProjectionRead_env_start_extending_lock(_ProjectionRead_env_start_extending_mutex); - _OpCache_with_parameter_env_start_extending.insert({readState, writeState}); - } + _OpCache_with_parameter_env_start_extending.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "env_start_extending"; - result.insert(copiedState); + copiedState.stateAccessedVia = "env_start_extending"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } LandingGear_R6::_ProjectionRead__tr_env_extend_gear_last read__tr_env_extend_gear_last_state = state._projected_state_for__tr_env_extend_gear_last(); + BSet<LandingGear_R6::POSITION> _trid_23; auto _trid_23_ptr = _OpCache_tr_env_extend_gear_last.find(read__tr_env_extend_gear_last_state); if(_trid_23_ptr == _OpCache_tr_env_extend_gear_last.end()) { - BSet<LandingGear_R6::POSITION> _trid_23 = state._tr_env_extend_gear_last(); + _trid_23 = state._tr_env_extend_gear_last(); { std::unique_lock<std::mutex> _ProjectionRead__tr_env_extend_gear_last_lock(_ProjectionRead__tr_env_extend_gear_last_mutex); _OpCache_tr_env_extend_gear_last.insert({read__tr_env_extend_gear_last_state, _trid_23}); } - for(const LandingGear_R6::POSITION& param : _trid_23) { - LandingGear_R6::POSITION _tmp_1 = param; - - LandingGear_R6 copiedState = state._copy(); - LandingGear_R6::_ProjectionRead_env_extend_gear_last readState = state._projected_state_for_env_extend_gear_last(); + } else { + _trid_23 = _trid_23_ptr->second; + } - auto _OpCache_with_parameter_env_extend_gear_last_ptr = _OpCache_env_extend_gear_last.find(param); - if(_OpCache_with_parameter_env_extend_gear_last_ptr == _OpCache_env_extend_gear_last.end()) { - copiedState.env_extend_gear_last(_tmp_1); - LandingGear_R6::_ProjectionWrite_env_extend_gear_last writeState = copiedState._update_for_env_extend_gear_last(); - std::unordered_map<LandingGear_R6::_ProjectionRead_env_extend_gear_last, LandingGear_R6::_ProjectionWrite_env_extend_gear_last, LandingGear_R6::_ProjectionRead_env_extend_gear_last::Hash, LandingGear_R6::_ProjectionRead_env_extend_gear_last::HashEqual> _OpCache_with_parameter_env_extend_gear_last; - _OpCache_with_parameter_env_extend_gear_last.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_env_extend_gear_last_lock(_ProjectionRead_env_extend_gear_last_mutex); - _OpCache_env_extend_gear_last.insert({param, _OpCache_with_parameter_env_extend_gear_last}); - } + for(const LandingGear_R6::POSITION& param : _trid_23) { + LandingGear_R6::POSITION _tmp_1 = param; - } else { - std::unordered_map<LandingGear_R6::_ProjectionRead_env_extend_gear_last, LandingGear_R6::_ProjectionWrite_env_extend_gear_last, LandingGear_R6::_ProjectionRead_env_extend_gear_last::Hash, LandingGear_R6::_ProjectionRead_env_extend_gear_last::HashEqual> _OpCache_with_parameter_env_extend_gear_last = _OpCache_with_parameter_env_extend_gear_last_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_env_extend_gear_last.find(readState); - if(writeState_ptr != _OpCache_with_parameter_env_extend_gear_last.end()) { - LandingGear_R6::_ProjectionWrite_env_extend_gear_last writeState = writeState_ptr->second; - copiedState._apply_update_for_env_extend_gear_last(writeState); - } else { - copiedState.env_extend_gear_last(_tmp_1); - LandingGear_R6::_ProjectionWrite_env_extend_gear_last writeState = copiedState._update_for_env_extend_gear_last(); - { - std::unique_lock<std::mutex> _ProjectionRead_env_extend_gear_last_lock(_ProjectionRead_env_extend_gear_last_mutex); - _OpCache_with_parameter_env_extend_gear_last.insert({readState, writeState}); - } - } + LandingGear_R6 copiedState = state._copy(); + LandingGear_R6::_ProjectionRead_env_extend_gear_last readState = state._projected_state_for_env_extend_gear_last(); + + auto _OpCache_with_parameter_env_extend_gear_last_ptr = _OpCache_env_extend_gear_last.find(param); + if(_OpCache_with_parameter_env_extend_gear_last_ptr == _OpCache_env_extend_gear_last.end()) { + copiedState.env_extend_gear_last(_tmp_1); + LandingGear_R6::_ProjectionWrite_env_extend_gear_last writeState = copiedState._update_for_env_extend_gear_last(); + std::unordered_map<LandingGear_R6::_ProjectionRead_env_extend_gear_last, LandingGear_R6::_ProjectionWrite_env_extend_gear_last, LandingGear_R6::_ProjectionRead_env_extend_gear_last::Hash, LandingGear_R6::_ProjectionRead_env_extend_gear_last::HashEqual> _OpCache_with_parameter_env_extend_gear_last; + _OpCache_with_parameter_env_extend_gear_last.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_env_extend_gear_last_lock(_ProjectionRead_env_extend_gear_last_mutex); + _OpCache_env_extend_gear_last.insert({param, _OpCache_with_parameter_env_extend_gear_last}); } - copiedState.stateAccessedVia = "env_extend_gear_last"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<LandingGear_R6::POSITION> _trid_23 = _trid_23_ptr->second; - for(const LandingGear_R6::POSITION& param : _trid_23) { - LandingGear_R6::POSITION _tmp_1 = param; - - LandingGear_R6 copiedState = state._copy(); - LandingGear_R6::_ProjectionRead_env_extend_gear_last readState = state._projected_state_for_env_extend_gear_last(); - - auto _OpCache_with_parameter_env_extend_gear_last_ptr = _OpCache_env_extend_gear_last.find(param); - if(_OpCache_with_parameter_env_extend_gear_last_ptr == _OpCache_env_extend_gear_last.end()) { + } else { + std::unordered_map<LandingGear_R6::_ProjectionRead_env_extend_gear_last, LandingGear_R6::_ProjectionWrite_env_extend_gear_last, LandingGear_R6::_ProjectionRead_env_extend_gear_last::Hash, LandingGear_R6::_ProjectionRead_env_extend_gear_last::HashEqual> _OpCache_with_parameter_env_extend_gear_last = _OpCache_with_parameter_env_extend_gear_last_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_env_extend_gear_last.find(readState); + if(writeState_ptr != _OpCache_with_parameter_env_extend_gear_last.end()) { + LandingGear_R6::_ProjectionWrite_env_extend_gear_last writeState = writeState_ptr->second; + copiedState._apply_update_for_env_extend_gear_last(writeState); + } else { copiedState.env_extend_gear_last(_tmp_1); LandingGear_R6::_ProjectionWrite_env_extend_gear_last writeState = copiedState._update_for_env_extend_gear_last(); - std::unordered_map<LandingGear_R6::_ProjectionRead_env_extend_gear_last, LandingGear_R6::_ProjectionWrite_env_extend_gear_last, LandingGear_R6::_ProjectionRead_env_extend_gear_last::Hash, LandingGear_R6::_ProjectionRead_env_extend_gear_last::HashEqual> _OpCache_with_parameter_env_extend_gear_last; - _OpCache_with_parameter_env_extend_gear_last.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_env_extend_gear_last_lock(_ProjectionRead_env_extend_gear_last_mutex); - _OpCache_env_extend_gear_last.insert({param, _OpCache_with_parameter_env_extend_gear_last}); - } - - } else { - std::unordered_map<LandingGear_R6::_ProjectionRead_env_extend_gear_last, LandingGear_R6::_ProjectionWrite_env_extend_gear_last, LandingGear_R6::_ProjectionRead_env_extend_gear_last::Hash, LandingGear_R6::_ProjectionRead_env_extend_gear_last::HashEqual> _OpCache_with_parameter_env_extend_gear_last = _OpCache_with_parameter_env_extend_gear_last_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_env_extend_gear_last.find(readState); - if(writeState_ptr != _OpCache_with_parameter_env_extend_gear_last.end()) { - LandingGear_R6::_ProjectionWrite_env_extend_gear_last writeState = writeState_ptr->second; - copiedState._apply_update_for_env_extend_gear_last(writeState); - } else { - copiedState.env_extend_gear_last(_tmp_1); - LandingGear_R6::_ProjectionWrite_env_extend_gear_last writeState = copiedState._update_for_env_extend_gear_last(); - { - std::unique_lock<std::mutex> _ProjectionRead_env_extend_gear_last_lock(_ProjectionRead_env_extend_gear_last_mutex); - _OpCache_with_parameter_env_extend_gear_last.insert({readState, writeState}); - } + _OpCache_with_parameter_env_extend_gear_last.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "env_extend_gear_last"; - result.insert(copiedState); + copiedState.stateAccessedVia = "env_extend_gear_last"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } LandingGear_R6::_ProjectionRead__tr_env_extend_gear_skip read__tr_env_extend_gear_skip_state = state._projected_state_for__tr_env_extend_gear_skip(); + BSet<LandingGear_R6::POSITION> _trid_24; auto _trid_24_ptr = _OpCache_tr_env_extend_gear_skip.find(read__tr_env_extend_gear_skip_state); if(_trid_24_ptr == _OpCache_tr_env_extend_gear_skip.end()) { - BSet<LandingGear_R6::POSITION> _trid_24 = state._tr_env_extend_gear_skip(); + _trid_24 = state._tr_env_extend_gear_skip(); { std::unique_lock<std::mutex> _ProjectionRead__tr_env_extend_gear_skip_lock(_ProjectionRead__tr_env_extend_gear_skip_mutex); _OpCache_tr_env_extend_gear_skip.insert({read__tr_env_extend_gear_skip_state, _trid_24}); } - for(const LandingGear_R6::POSITION& param : _trid_24) { - LandingGear_R6::POSITION _tmp_1 = param; + } else { + _trid_24 = _trid_24_ptr->second; + } + + for(const LandingGear_R6::POSITION& param : _trid_24) { + LandingGear_R6::POSITION _tmp_1 = param; - LandingGear_R6 copiedState = state._copy(); - LandingGear_R6::_ProjectionRead_env_extend_gear_skip readState = state._projected_state_for_env_extend_gear_skip(); + LandingGear_R6 copiedState = state._copy(); + LandingGear_R6::_ProjectionRead_env_extend_gear_skip readState = state._projected_state_for_env_extend_gear_skip(); + + auto _OpCache_with_parameter_env_extend_gear_skip_ptr = _OpCache_env_extend_gear_skip.find(param); + if(_OpCache_with_parameter_env_extend_gear_skip_ptr == _OpCache_env_extend_gear_skip.end()) { + copiedState.env_extend_gear_skip(_tmp_1); + LandingGear_R6::_ProjectionWrite_env_extend_gear_skip writeState = copiedState._update_for_env_extend_gear_skip(); + std::unordered_map<LandingGear_R6::_ProjectionRead_env_extend_gear_skip, LandingGear_R6::_ProjectionWrite_env_extend_gear_skip, LandingGear_R6::_ProjectionRead_env_extend_gear_skip::Hash, LandingGear_R6::_ProjectionRead_env_extend_gear_skip::HashEqual> _OpCache_with_parameter_env_extend_gear_skip; + _OpCache_with_parameter_env_extend_gear_skip.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_env_extend_gear_skip_lock(_ProjectionRead_env_extend_gear_skip_mutex); + _OpCache_env_extend_gear_skip.insert({param, _OpCache_with_parameter_env_extend_gear_skip}); + } - auto _OpCache_with_parameter_env_extend_gear_skip_ptr = _OpCache_env_extend_gear_skip.find(param); - if(_OpCache_with_parameter_env_extend_gear_skip_ptr == _OpCache_env_extend_gear_skip.end()) { + } else { + std::unordered_map<LandingGear_R6::_ProjectionRead_env_extend_gear_skip, LandingGear_R6::_ProjectionWrite_env_extend_gear_skip, LandingGear_R6::_ProjectionRead_env_extend_gear_skip::Hash, LandingGear_R6::_ProjectionRead_env_extend_gear_skip::HashEqual> _OpCache_with_parameter_env_extend_gear_skip = _OpCache_with_parameter_env_extend_gear_skip_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_env_extend_gear_skip.find(readState); + if(writeState_ptr != _OpCache_with_parameter_env_extend_gear_skip.end()) { + LandingGear_R6::_ProjectionWrite_env_extend_gear_skip writeState = writeState_ptr->second; + copiedState._apply_update_for_env_extend_gear_skip(writeState); + } else { copiedState.env_extend_gear_skip(_tmp_1); LandingGear_R6::_ProjectionWrite_env_extend_gear_skip writeState = copiedState._update_for_env_extend_gear_skip(); - std::unordered_map<LandingGear_R6::_ProjectionRead_env_extend_gear_skip, LandingGear_R6::_ProjectionWrite_env_extend_gear_skip, LandingGear_R6::_ProjectionRead_env_extend_gear_skip::Hash, LandingGear_R6::_ProjectionRead_env_extend_gear_skip::HashEqual> _OpCache_with_parameter_env_extend_gear_skip; - _OpCache_with_parameter_env_extend_gear_skip.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_env_extend_gear_skip_lock(_ProjectionRead_env_extend_gear_skip_mutex); - _OpCache_env_extend_gear_skip.insert({param, _OpCache_with_parameter_env_extend_gear_skip}); - } - - } else { - std::unordered_map<LandingGear_R6::_ProjectionRead_env_extend_gear_skip, LandingGear_R6::_ProjectionWrite_env_extend_gear_skip, LandingGear_R6::_ProjectionRead_env_extend_gear_skip::Hash, LandingGear_R6::_ProjectionRead_env_extend_gear_skip::HashEqual> _OpCache_with_parameter_env_extend_gear_skip = _OpCache_with_parameter_env_extend_gear_skip_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_env_extend_gear_skip.find(readState); - if(writeState_ptr != _OpCache_with_parameter_env_extend_gear_skip.end()) { - LandingGear_R6::_ProjectionWrite_env_extend_gear_skip writeState = writeState_ptr->second; - copiedState._apply_update_for_env_extend_gear_skip(writeState); - } else { - copiedState.env_extend_gear_skip(_tmp_1); - LandingGear_R6::_ProjectionWrite_env_extend_gear_skip writeState = copiedState._update_for_env_extend_gear_skip(); - { - std::unique_lock<std::mutex> _ProjectionRead_env_extend_gear_skip_lock(_ProjectionRead_env_extend_gear_skip_mutex); - _OpCache_with_parameter_env_extend_gear_skip.insert({readState, writeState}); - } + _OpCache_with_parameter_env_extend_gear_skip.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "env_extend_gear_skip"; - result.insert(copiedState); + copiedState.stateAccessedVia = "env_extend_gear_skip"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } + } + LandingGear_R6::_ProjectionRead__tr_env_start_open_door read__tr_env_start_open_door_state = state._projected_state_for__tr_env_start_open_door(); + BSet<LandingGear_R6::POSITION> _trid_25; + auto _trid_25_ptr = _OpCache_tr_env_start_open_door.find(read__tr_env_start_open_door_state); + if(_trid_25_ptr == _OpCache_tr_env_start_open_door.end()) { + _trid_25 = state._tr_env_start_open_door(); + { + std::unique_lock<std::mutex> _ProjectionRead__tr_env_start_open_door_lock(_ProjectionRead__tr_env_start_open_door_mutex); + _OpCache_tr_env_start_open_door.insert({read__tr_env_start_open_door_state, _trid_25}); + } } else { - BSet<LandingGear_R6::POSITION> _trid_24 = _trid_24_ptr->second; - for(const LandingGear_R6::POSITION& param : _trid_24) { - LandingGear_R6::POSITION _tmp_1 = param; - - LandingGear_R6 copiedState = state._copy(); - LandingGear_R6::_ProjectionRead_env_extend_gear_skip readState = state._projected_state_for_env_extend_gear_skip(); - - auto _OpCache_with_parameter_env_extend_gear_skip_ptr = _OpCache_env_extend_gear_skip.find(param); - if(_OpCache_with_parameter_env_extend_gear_skip_ptr == _OpCache_env_extend_gear_skip.end()) { - copiedState.env_extend_gear_skip(_tmp_1); - LandingGear_R6::_ProjectionWrite_env_extend_gear_skip writeState = copiedState._update_for_env_extend_gear_skip(); - std::unordered_map<LandingGear_R6::_ProjectionRead_env_extend_gear_skip, LandingGear_R6::_ProjectionWrite_env_extend_gear_skip, LandingGear_R6::_ProjectionRead_env_extend_gear_skip::Hash, LandingGear_R6::_ProjectionRead_env_extend_gear_skip::HashEqual> _OpCache_with_parameter_env_extend_gear_skip; - _OpCache_with_parameter_env_extend_gear_skip.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_env_extend_gear_skip_lock(_ProjectionRead_env_extend_gear_skip_mutex); - _OpCache_env_extend_gear_skip.insert({param, _OpCache_with_parameter_env_extend_gear_skip}); - } - - } else { - std::unordered_map<LandingGear_R6::_ProjectionRead_env_extend_gear_skip, LandingGear_R6::_ProjectionWrite_env_extend_gear_skip, LandingGear_R6::_ProjectionRead_env_extend_gear_skip::Hash, LandingGear_R6::_ProjectionRead_env_extend_gear_skip::HashEqual> _OpCache_with_parameter_env_extend_gear_skip = _OpCache_with_parameter_env_extend_gear_skip_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_env_extend_gear_skip.find(readState); - if(writeState_ptr != _OpCache_with_parameter_env_extend_gear_skip.end()) { - LandingGear_R6::_ProjectionWrite_env_extend_gear_skip writeState = writeState_ptr->second; - copiedState._apply_update_for_env_extend_gear_skip(writeState); - } else { - copiedState.env_extend_gear_skip(_tmp_1); - LandingGear_R6::_ProjectionWrite_env_extend_gear_skip writeState = copiedState._update_for_env_extend_gear_skip(); - { - std::unique_lock<std::mutex> _ProjectionRead_env_extend_gear_skip_lock(_ProjectionRead_env_extend_gear_skip_mutex); - _OpCache_with_parameter_env_extend_gear_skip.insert({readState, writeState}); - } - } - } - - copiedState.stateAccessedVia = "env_extend_gear_skip"; - result.insert(copiedState); - transitions += 1; - } + _trid_25 = _trid_25_ptr->second; } - LandingGear_R6::_ProjectionRead__tr_env_start_open_door read__tr_env_start_open_door_state = state._projected_state_for__tr_env_start_open_door(); - auto _trid_25_ptr = _OpCache_tr_env_start_open_door.find(read__tr_env_start_open_door_state); - if(_trid_25_ptr == _OpCache_tr_env_start_open_door.end()) { - BSet<LandingGear_R6::POSITION> _trid_25 = state._tr_env_start_open_door(); - { - std::unique_lock<std::mutex> _ProjectionRead__tr_env_start_open_door_lock(_ProjectionRead__tr_env_start_open_door_mutex); - _OpCache_tr_env_start_open_door.insert({read__tr_env_start_open_door_state, _trid_25}); - } - for(const LandingGear_R6::POSITION& param : _trid_25) { - LandingGear_R6::POSITION _tmp_1 = param; - LandingGear_R6 copiedState = state._copy(); - LandingGear_R6::_ProjectionRead_env_start_open_door readState = state._projected_state_for_env_start_open_door(); - - auto _OpCache_with_parameter_env_start_open_door_ptr = _OpCache_env_start_open_door.find(param); - if(_OpCache_with_parameter_env_start_open_door_ptr == _OpCache_env_start_open_door.end()) { - copiedState.env_start_open_door(_tmp_1); - LandingGear_R6::_ProjectionWrite_env_start_open_door writeState = copiedState._update_for_env_start_open_door(); - std::unordered_map<LandingGear_R6::_ProjectionRead_env_start_open_door, LandingGear_R6::_ProjectionWrite_env_start_open_door, LandingGear_R6::_ProjectionRead_env_start_open_door::Hash, LandingGear_R6::_ProjectionRead_env_start_open_door::HashEqual> _OpCache_with_parameter_env_start_open_door; - _OpCache_with_parameter_env_start_open_door.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_env_start_open_door_lock(_ProjectionRead_env_start_open_door_mutex); - _OpCache_env_start_open_door.insert({param, _OpCache_with_parameter_env_start_open_door}); - } + for(const LandingGear_R6::POSITION& param : _trid_25) { + LandingGear_R6::POSITION _tmp_1 = param; - } else { - std::unordered_map<LandingGear_R6::_ProjectionRead_env_start_open_door, LandingGear_R6::_ProjectionWrite_env_start_open_door, LandingGear_R6::_ProjectionRead_env_start_open_door::Hash, LandingGear_R6::_ProjectionRead_env_start_open_door::HashEqual> _OpCache_with_parameter_env_start_open_door = _OpCache_with_parameter_env_start_open_door_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_env_start_open_door.find(readState); - if(writeState_ptr != _OpCache_with_parameter_env_start_open_door.end()) { - LandingGear_R6::_ProjectionWrite_env_start_open_door writeState = writeState_ptr->second; - copiedState._apply_update_for_env_start_open_door(writeState); - } else { - copiedState.env_start_open_door(_tmp_1); - LandingGear_R6::_ProjectionWrite_env_start_open_door writeState = copiedState._update_for_env_start_open_door(); - { - std::unique_lock<std::mutex> _ProjectionRead_env_start_open_door_lock(_ProjectionRead_env_start_open_door_mutex); - _OpCache_with_parameter_env_start_open_door.insert({readState, writeState}); - } - } + LandingGear_R6 copiedState = state._copy(); + LandingGear_R6::_ProjectionRead_env_start_open_door readState = state._projected_state_for_env_start_open_door(); + + auto _OpCache_with_parameter_env_start_open_door_ptr = _OpCache_env_start_open_door.find(param); + if(_OpCache_with_parameter_env_start_open_door_ptr == _OpCache_env_start_open_door.end()) { + copiedState.env_start_open_door(_tmp_1); + LandingGear_R6::_ProjectionWrite_env_start_open_door writeState = copiedState._update_for_env_start_open_door(); + std::unordered_map<LandingGear_R6::_ProjectionRead_env_start_open_door, LandingGear_R6::_ProjectionWrite_env_start_open_door, LandingGear_R6::_ProjectionRead_env_start_open_door::Hash, LandingGear_R6::_ProjectionRead_env_start_open_door::HashEqual> _OpCache_with_parameter_env_start_open_door; + _OpCache_with_parameter_env_start_open_door.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_env_start_open_door_lock(_ProjectionRead_env_start_open_door_mutex); + _OpCache_env_start_open_door.insert({param, _OpCache_with_parameter_env_start_open_door}); } - copiedState.stateAccessedVia = "env_start_open_door"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<LandingGear_R6::POSITION> _trid_25 = _trid_25_ptr->second; - for(const LandingGear_R6::POSITION& param : _trid_25) { - LandingGear_R6::POSITION _tmp_1 = param; - - LandingGear_R6 copiedState = state._copy(); - LandingGear_R6::_ProjectionRead_env_start_open_door readState = state._projected_state_for_env_start_open_door(); - - auto _OpCache_with_parameter_env_start_open_door_ptr = _OpCache_env_start_open_door.find(param); - if(_OpCache_with_parameter_env_start_open_door_ptr == _OpCache_env_start_open_door.end()) { + } else { + std::unordered_map<LandingGear_R6::_ProjectionRead_env_start_open_door, LandingGear_R6::_ProjectionWrite_env_start_open_door, LandingGear_R6::_ProjectionRead_env_start_open_door::Hash, LandingGear_R6::_ProjectionRead_env_start_open_door::HashEqual> _OpCache_with_parameter_env_start_open_door = _OpCache_with_parameter_env_start_open_door_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_env_start_open_door.find(readState); + if(writeState_ptr != _OpCache_with_parameter_env_start_open_door.end()) { + LandingGear_R6::_ProjectionWrite_env_start_open_door writeState = writeState_ptr->second; + copiedState._apply_update_for_env_start_open_door(writeState); + } else { copiedState.env_start_open_door(_tmp_1); LandingGear_R6::_ProjectionWrite_env_start_open_door writeState = copiedState._update_for_env_start_open_door(); - std::unordered_map<LandingGear_R6::_ProjectionRead_env_start_open_door, LandingGear_R6::_ProjectionWrite_env_start_open_door, LandingGear_R6::_ProjectionRead_env_start_open_door::Hash, LandingGear_R6::_ProjectionRead_env_start_open_door::HashEqual> _OpCache_with_parameter_env_start_open_door; - _OpCache_with_parameter_env_start_open_door.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_env_start_open_door_lock(_ProjectionRead_env_start_open_door_mutex); - _OpCache_env_start_open_door.insert({param, _OpCache_with_parameter_env_start_open_door}); - } - - } else { - std::unordered_map<LandingGear_R6::_ProjectionRead_env_start_open_door, LandingGear_R6::_ProjectionWrite_env_start_open_door, LandingGear_R6::_ProjectionRead_env_start_open_door::Hash, LandingGear_R6::_ProjectionRead_env_start_open_door::HashEqual> _OpCache_with_parameter_env_start_open_door = _OpCache_with_parameter_env_start_open_door_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_env_start_open_door.find(readState); - if(writeState_ptr != _OpCache_with_parameter_env_start_open_door.end()) { - LandingGear_R6::_ProjectionWrite_env_start_open_door writeState = writeState_ptr->second; - copiedState._apply_update_for_env_start_open_door(writeState); - } else { - copiedState.env_start_open_door(_tmp_1); - LandingGear_R6::_ProjectionWrite_env_start_open_door writeState = copiedState._update_for_env_start_open_door(); - { - std::unique_lock<std::mutex> _ProjectionRead_env_start_open_door_lock(_ProjectionRead_env_start_open_door_mutex); - _OpCache_with_parameter_env_start_open_door.insert({readState, writeState}); - } + _OpCache_with_parameter_env_start_open_door.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "env_start_open_door"; - result.insert(copiedState); + copiedState.stateAccessedVia = "env_start_open_door"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } LandingGear_R6::_ProjectionRead__tr_env_open_door_last read__tr_env_open_door_last_state = state._projected_state_for__tr_env_open_door_last(); + BSet<LandingGear_R6::POSITION> _trid_26; auto _trid_26_ptr = _OpCache_tr_env_open_door_last.find(read__tr_env_open_door_last_state); if(_trid_26_ptr == _OpCache_tr_env_open_door_last.end()) { - BSet<LandingGear_R6::POSITION> _trid_26 = state._tr_env_open_door_last(); + _trid_26 = state._tr_env_open_door_last(); { std::unique_lock<std::mutex> _ProjectionRead__tr_env_open_door_last_lock(_ProjectionRead__tr_env_open_door_last_mutex); _OpCache_tr_env_open_door_last.insert({read__tr_env_open_door_last_state, _trid_26}); } - for(const LandingGear_R6::POSITION& param : _trid_26) { - LandingGear_R6::POSITION _tmp_1 = param; - - LandingGear_R6 copiedState = state._copy(); - LandingGear_R6::_ProjectionRead_env_open_door_last readState = state._projected_state_for_env_open_door_last(); + } else { + _trid_26 = _trid_26_ptr->second; + } - auto _OpCache_with_parameter_env_open_door_last_ptr = _OpCache_env_open_door_last.find(param); - if(_OpCache_with_parameter_env_open_door_last_ptr == _OpCache_env_open_door_last.end()) { - copiedState.env_open_door_last(_tmp_1); - LandingGear_R6::_ProjectionWrite_env_open_door_last writeState = copiedState._update_for_env_open_door_last(); - std::unordered_map<LandingGear_R6::_ProjectionRead_env_open_door_last, LandingGear_R6::_ProjectionWrite_env_open_door_last, LandingGear_R6::_ProjectionRead_env_open_door_last::Hash, LandingGear_R6::_ProjectionRead_env_open_door_last::HashEqual> _OpCache_with_parameter_env_open_door_last; - _OpCache_with_parameter_env_open_door_last.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_env_open_door_last_lock(_ProjectionRead_env_open_door_last_mutex); - _OpCache_env_open_door_last.insert({param, _OpCache_with_parameter_env_open_door_last}); - } + for(const LandingGear_R6::POSITION& param : _trid_26) { + LandingGear_R6::POSITION _tmp_1 = param; - } else { - std::unordered_map<LandingGear_R6::_ProjectionRead_env_open_door_last, LandingGear_R6::_ProjectionWrite_env_open_door_last, LandingGear_R6::_ProjectionRead_env_open_door_last::Hash, LandingGear_R6::_ProjectionRead_env_open_door_last::HashEqual> _OpCache_with_parameter_env_open_door_last = _OpCache_with_parameter_env_open_door_last_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_env_open_door_last.find(readState); - if(writeState_ptr != _OpCache_with_parameter_env_open_door_last.end()) { - LandingGear_R6::_ProjectionWrite_env_open_door_last writeState = writeState_ptr->second; - copiedState._apply_update_for_env_open_door_last(writeState); - } else { - copiedState.env_open_door_last(_tmp_1); - LandingGear_R6::_ProjectionWrite_env_open_door_last writeState = copiedState._update_for_env_open_door_last(); - { - std::unique_lock<std::mutex> _ProjectionRead_env_open_door_last_lock(_ProjectionRead_env_open_door_last_mutex); - _OpCache_with_parameter_env_open_door_last.insert({readState, writeState}); - } - } + LandingGear_R6 copiedState = state._copy(); + LandingGear_R6::_ProjectionRead_env_open_door_last readState = state._projected_state_for_env_open_door_last(); + + auto _OpCache_with_parameter_env_open_door_last_ptr = _OpCache_env_open_door_last.find(param); + if(_OpCache_with_parameter_env_open_door_last_ptr == _OpCache_env_open_door_last.end()) { + copiedState.env_open_door_last(_tmp_1); + LandingGear_R6::_ProjectionWrite_env_open_door_last writeState = copiedState._update_for_env_open_door_last(); + std::unordered_map<LandingGear_R6::_ProjectionRead_env_open_door_last, LandingGear_R6::_ProjectionWrite_env_open_door_last, LandingGear_R6::_ProjectionRead_env_open_door_last::Hash, LandingGear_R6::_ProjectionRead_env_open_door_last::HashEqual> _OpCache_with_parameter_env_open_door_last; + _OpCache_with_parameter_env_open_door_last.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_env_open_door_last_lock(_ProjectionRead_env_open_door_last_mutex); + _OpCache_env_open_door_last.insert({param, _OpCache_with_parameter_env_open_door_last}); } - copiedState.stateAccessedVia = "env_open_door_last"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<LandingGear_R6::POSITION> _trid_26 = _trid_26_ptr->second; - for(const LandingGear_R6::POSITION& param : _trid_26) { - LandingGear_R6::POSITION _tmp_1 = param; - - LandingGear_R6 copiedState = state._copy(); - LandingGear_R6::_ProjectionRead_env_open_door_last readState = state._projected_state_for_env_open_door_last(); - - auto _OpCache_with_parameter_env_open_door_last_ptr = _OpCache_env_open_door_last.find(param); - if(_OpCache_with_parameter_env_open_door_last_ptr == _OpCache_env_open_door_last.end()) { + } else { + std::unordered_map<LandingGear_R6::_ProjectionRead_env_open_door_last, LandingGear_R6::_ProjectionWrite_env_open_door_last, LandingGear_R6::_ProjectionRead_env_open_door_last::Hash, LandingGear_R6::_ProjectionRead_env_open_door_last::HashEqual> _OpCache_with_parameter_env_open_door_last = _OpCache_with_parameter_env_open_door_last_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_env_open_door_last.find(readState); + if(writeState_ptr != _OpCache_with_parameter_env_open_door_last.end()) { + LandingGear_R6::_ProjectionWrite_env_open_door_last writeState = writeState_ptr->second; + copiedState._apply_update_for_env_open_door_last(writeState); + } else { copiedState.env_open_door_last(_tmp_1); LandingGear_R6::_ProjectionWrite_env_open_door_last writeState = copiedState._update_for_env_open_door_last(); - std::unordered_map<LandingGear_R6::_ProjectionRead_env_open_door_last, LandingGear_R6::_ProjectionWrite_env_open_door_last, LandingGear_R6::_ProjectionRead_env_open_door_last::Hash, LandingGear_R6::_ProjectionRead_env_open_door_last::HashEqual> _OpCache_with_parameter_env_open_door_last; - _OpCache_with_parameter_env_open_door_last.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_env_open_door_last_lock(_ProjectionRead_env_open_door_last_mutex); - _OpCache_env_open_door_last.insert({param, _OpCache_with_parameter_env_open_door_last}); - } - - } else { - std::unordered_map<LandingGear_R6::_ProjectionRead_env_open_door_last, LandingGear_R6::_ProjectionWrite_env_open_door_last, LandingGear_R6::_ProjectionRead_env_open_door_last::Hash, LandingGear_R6::_ProjectionRead_env_open_door_last::HashEqual> _OpCache_with_parameter_env_open_door_last = _OpCache_with_parameter_env_open_door_last_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_env_open_door_last.find(readState); - if(writeState_ptr != _OpCache_with_parameter_env_open_door_last.end()) { - LandingGear_R6::_ProjectionWrite_env_open_door_last writeState = writeState_ptr->second; - copiedState._apply_update_for_env_open_door_last(writeState); - } else { - copiedState.env_open_door_last(_tmp_1); - LandingGear_R6::_ProjectionWrite_env_open_door_last writeState = copiedState._update_for_env_open_door_last(); - { - std::unique_lock<std::mutex> _ProjectionRead_env_open_door_last_lock(_ProjectionRead_env_open_door_last_mutex); - _OpCache_with_parameter_env_open_door_last.insert({readState, writeState}); - } + _OpCache_with_parameter_env_open_door_last.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "env_open_door_last"; - result.insert(copiedState); + copiedState.stateAccessedVia = "env_open_door_last"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } LandingGear_R6::_ProjectionRead__tr_env_open_door_skip read__tr_env_open_door_skip_state = state._projected_state_for__tr_env_open_door_skip(); + BSet<LandingGear_R6::POSITION> _trid_27; auto _trid_27_ptr = _OpCache_tr_env_open_door_skip.find(read__tr_env_open_door_skip_state); if(_trid_27_ptr == _OpCache_tr_env_open_door_skip.end()) { - BSet<LandingGear_R6::POSITION> _trid_27 = state._tr_env_open_door_skip(); + _trid_27 = state._tr_env_open_door_skip(); { std::unique_lock<std::mutex> _ProjectionRead__tr_env_open_door_skip_lock(_ProjectionRead__tr_env_open_door_skip_mutex); _OpCache_tr_env_open_door_skip.insert({read__tr_env_open_door_skip_state, _trid_27}); } - for(const LandingGear_R6::POSITION& param : _trid_27) { - LandingGear_R6::POSITION _tmp_1 = param; - - LandingGear_R6 copiedState = state._copy(); - LandingGear_R6::_ProjectionRead_env_open_door_skip readState = state._projected_state_for_env_open_door_skip(); + } else { + _trid_27 = _trid_27_ptr->second; + } - auto _OpCache_with_parameter_env_open_door_skip_ptr = _OpCache_env_open_door_skip.find(param); - if(_OpCache_with_parameter_env_open_door_skip_ptr == _OpCache_env_open_door_skip.end()) { - copiedState.env_open_door_skip(_tmp_1); - LandingGear_R6::_ProjectionWrite_env_open_door_skip writeState = copiedState._update_for_env_open_door_skip(); - std::unordered_map<LandingGear_R6::_ProjectionRead_env_open_door_skip, LandingGear_R6::_ProjectionWrite_env_open_door_skip, LandingGear_R6::_ProjectionRead_env_open_door_skip::Hash, LandingGear_R6::_ProjectionRead_env_open_door_skip::HashEqual> _OpCache_with_parameter_env_open_door_skip; - _OpCache_with_parameter_env_open_door_skip.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_env_open_door_skip_lock(_ProjectionRead_env_open_door_skip_mutex); - _OpCache_env_open_door_skip.insert({param, _OpCache_with_parameter_env_open_door_skip}); - } + for(const LandingGear_R6::POSITION& param : _trid_27) { + LandingGear_R6::POSITION _tmp_1 = param; - } else { - std::unordered_map<LandingGear_R6::_ProjectionRead_env_open_door_skip, LandingGear_R6::_ProjectionWrite_env_open_door_skip, LandingGear_R6::_ProjectionRead_env_open_door_skip::Hash, LandingGear_R6::_ProjectionRead_env_open_door_skip::HashEqual> _OpCache_with_parameter_env_open_door_skip = _OpCache_with_parameter_env_open_door_skip_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_env_open_door_skip.find(readState); - if(writeState_ptr != _OpCache_with_parameter_env_open_door_skip.end()) { - LandingGear_R6::_ProjectionWrite_env_open_door_skip writeState = writeState_ptr->second; - copiedState._apply_update_for_env_open_door_skip(writeState); - } else { - copiedState.env_open_door_skip(_tmp_1); - LandingGear_R6::_ProjectionWrite_env_open_door_skip writeState = copiedState._update_for_env_open_door_skip(); - { - std::unique_lock<std::mutex> _ProjectionRead_env_open_door_skip_lock(_ProjectionRead_env_open_door_skip_mutex); - _OpCache_with_parameter_env_open_door_skip.insert({readState, writeState}); - } - } + LandingGear_R6 copiedState = state._copy(); + LandingGear_R6::_ProjectionRead_env_open_door_skip readState = state._projected_state_for_env_open_door_skip(); + + auto _OpCache_with_parameter_env_open_door_skip_ptr = _OpCache_env_open_door_skip.find(param); + if(_OpCache_with_parameter_env_open_door_skip_ptr == _OpCache_env_open_door_skip.end()) { + copiedState.env_open_door_skip(_tmp_1); + LandingGear_R6::_ProjectionWrite_env_open_door_skip writeState = copiedState._update_for_env_open_door_skip(); + std::unordered_map<LandingGear_R6::_ProjectionRead_env_open_door_skip, LandingGear_R6::_ProjectionWrite_env_open_door_skip, LandingGear_R6::_ProjectionRead_env_open_door_skip::Hash, LandingGear_R6::_ProjectionRead_env_open_door_skip::HashEqual> _OpCache_with_parameter_env_open_door_skip; + _OpCache_with_parameter_env_open_door_skip.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_env_open_door_skip_lock(_ProjectionRead_env_open_door_skip_mutex); + _OpCache_env_open_door_skip.insert({param, _OpCache_with_parameter_env_open_door_skip}); } - copiedState.stateAccessedVia = "env_open_door_skip"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<LandingGear_R6::POSITION> _trid_27 = _trid_27_ptr->second; - for(const LandingGear_R6::POSITION& param : _trid_27) { - LandingGear_R6::POSITION _tmp_1 = param; - - LandingGear_R6 copiedState = state._copy(); - LandingGear_R6::_ProjectionRead_env_open_door_skip readState = state._projected_state_for_env_open_door_skip(); - - auto _OpCache_with_parameter_env_open_door_skip_ptr = _OpCache_env_open_door_skip.find(param); - if(_OpCache_with_parameter_env_open_door_skip_ptr == _OpCache_env_open_door_skip.end()) { + } else { + std::unordered_map<LandingGear_R6::_ProjectionRead_env_open_door_skip, LandingGear_R6::_ProjectionWrite_env_open_door_skip, LandingGear_R6::_ProjectionRead_env_open_door_skip::Hash, LandingGear_R6::_ProjectionRead_env_open_door_skip::HashEqual> _OpCache_with_parameter_env_open_door_skip = _OpCache_with_parameter_env_open_door_skip_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_env_open_door_skip.find(readState); + if(writeState_ptr != _OpCache_with_parameter_env_open_door_skip.end()) { + LandingGear_R6::_ProjectionWrite_env_open_door_skip writeState = writeState_ptr->second; + copiedState._apply_update_for_env_open_door_skip(writeState); + } else { copiedState.env_open_door_skip(_tmp_1); LandingGear_R6::_ProjectionWrite_env_open_door_skip writeState = copiedState._update_for_env_open_door_skip(); - std::unordered_map<LandingGear_R6::_ProjectionRead_env_open_door_skip, LandingGear_R6::_ProjectionWrite_env_open_door_skip, LandingGear_R6::_ProjectionRead_env_open_door_skip::Hash, LandingGear_R6::_ProjectionRead_env_open_door_skip::HashEqual> _OpCache_with_parameter_env_open_door_skip; - _OpCache_with_parameter_env_open_door_skip.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_env_open_door_skip_lock(_ProjectionRead_env_open_door_skip_mutex); - _OpCache_env_open_door_skip.insert({param, _OpCache_with_parameter_env_open_door_skip}); - } - - } else { - std::unordered_map<LandingGear_R6::_ProjectionRead_env_open_door_skip, LandingGear_R6::_ProjectionWrite_env_open_door_skip, LandingGear_R6::_ProjectionRead_env_open_door_skip::Hash, LandingGear_R6::_ProjectionRead_env_open_door_skip::HashEqual> _OpCache_with_parameter_env_open_door_skip = _OpCache_with_parameter_env_open_door_skip_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_env_open_door_skip.find(readState); - if(writeState_ptr != _OpCache_with_parameter_env_open_door_skip.end()) { - LandingGear_R6::_ProjectionWrite_env_open_door_skip writeState = writeState_ptr->second; - copiedState._apply_update_for_env_open_door_skip(writeState); - } else { - copiedState.env_open_door_skip(_tmp_1); - LandingGear_R6::_ProjectionWrite_env_open_door_skip writeState = copiedState._update_for_env_open_door_skip(); - { - std::unique_lock<std::mutex> _ProjectionRead_env_open_door_skip_lock(_ProjectionRead_env_open_door_skip_mutex); - _OpCache_with_parameter_env_open_door_skip.insert({readState, writeState}); - } + _OpCache_with_parameter_env_open_door_skip.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "env_open_door_skip"; - result.insert(copiedState); + copiedState.stateAccessedVia = "env_open_door_skip"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } LandingGear_R6::_ProjectionRead__tr_env_start_close_door read__tr_env_start_close_door_state = state._projected_state_for__tr_env_start_close_door(); + BSet<LandingGear_R6::POSITION> _trid_28; auto _trid_28_ptr = _OpCache_tr_env_start_close_door.find(read__tr_env_start_close_door_state); if(_trid_28_ptr == _OpCache_tr_env_start_close_door.end()) { - BSet<LandingGear_R6::POSITION> _trid_28 = state._tr_env_start_close_door(); + _trid_28 = state._tr_env_start_close_door(); { std::unique_lock<std::mutex> _ProjectionRead__tr_env_start_close_door_lock(_ProjectionRead__tr_env_start_close_door_mutex); _OpCache_tr_env_start_close_door.insert({read__tr_env_start_close_door_state, _trid_28}); } - for(const LandingGear_R6::POSITION& param : _trid_28) { - LandingGear_R6::POSITION _tmp_1 = param; - - LandingGear_R6 copiedState = state._copy(); - LandingGear_R6::_ProjectionRead_env_start_close_door readState = state._projected_state_for_env_start_close_door(); + } else { + _trid_28 = _trid_28_ptr->second; + } - auto _OpCache_with_parameter_env_start_close_door_ptr = _OpCache_env_start_close_door.find(param); - if(_OpCache_with_parameter_env_start_close_door_ptr == _OpCache_env_start_close_door.end()) { - copiedState.env_start_close_door(_tmp_1); - LandingGear_R6::_ProjectionWrite_env_start_close_door writeState = copiedState._update_for_env_start_close_door(); - std::unordered_map<LandingGear_R6::_ProjectionRead_env_start_close_door, LandingGear_R6::_ProjectionWrite_env_start_close_door, LandingGear_R6::_ProjectionRead_env_start_close_door::Hash, LandingGear_R6::_ProjectionRead_env_start_close_door::HashEqual> _OpCache_with_parameter_env_start_close_door; - _OpCache_with_parameter_env_start_close_door.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_env_start_close_door_lock(_ProjectionRead_env_start_close_door_mutex); - _OpCache_env_start_close_door.insert({param, _OpCache_with_parameter_env_start_close_door}); - } + for(const LandingGear_R6::POSITION& param : _trid_28) { + LandingGear_R6::POSITION _tmp_1 = param; - } else { - std::unordered_map<LandingGear_R6::_ProjectionRead_env_start_close_door, LandingGear_R6::_ProjectionWrite_env_start_close_door, LandingGear_R6::_ProjectionRead_env_start_close_door::Hash, LandingGear_R6::_ProjectionRead_env_start_close_door::HashEqual> _OpCache_with_parameter_env_start_close_door = _OpCache_with_parameter_env_start_close_door_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_env_start_close_door.find(readState); - if(writeState_ptr != _OpCache_with_parameter_env_start_close_door.end()) { - LandingGear_R6::_ProjectionWrite_env_start_close_door writeState = writeState_ptr->second; - copiedState._apply_update_for_env_start_close_door(writeState); - } else { - copiedState.env_start_close_door(_tmp_1); - LandingGear_R6::_ProjectionWrite_env_start_close_door writeState = copiedState._update_for_env_start_close_door(); - { - std::unique_lock<std::mutex> _ProjectionRead_env_start_close_door_lock(_ProjectionRead_env_start_close_door_mutex); - _OpCache_with_parameter_env_start_close_door.insert({readState, writeState}); - } - } + LandingGear_R6 copiedState = state._copy(); + LandingGear_R6::_ProjectionRead_env_start_close_door readState = state._projected_state_for_env_start_close_door(); + + auto _OpCache_with_parameter_env_start_close_door_ptr = _OpCache_env_start_close_door.find(param); + if(_OpCache_with_parameter_env_start_close_door_ptr == _OpCache_env_start_close_door.end()) { + copiedState.env_start_close_door(_tmp_1); + LandingGear_R6::_ProjectionWrite_env_start_close_door writeState = copiedState._update_for_env_start_close_door(); + std::unordered_map<LandingGear_R6::_ProjectionRead_env_start_close_door, LandingGear_R6::_ProjectionWrite_env_start_close_door, LandingGear_R6::_ProjectionRead_env_start_close_door::Hash, LandingGear_R6::_ProjectionRead_env_start_close_door::HashEqual> _OpCache_with_parameter_env_start_close_door; + _OpCache_with_parameter_env_start_close_door.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_env_start_close_door_lock(_ProjectionRead_env_start_close_door_mutex); + _OpCache_env_start_close_door.insert({param, _OpCache_with_parameter_env_start_close_door}); } - copiedState.stateAccessedVia = "env_start_close_door"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<LandingGear_R6::POSITION> _trid_28 = _trid_28_ptr->second; - for(const LandingGear_R6::POSITION& param : _trid_28) { - LandingGear_R6::POSITION _tmp_1 = param; - - LandingGear_R6 copiedState = state._copy(); - LandingGear_R6::_ProjectionRead_env_start_close_door readState = state._projected_state_for_env_start_close_door(); - - auto _OpCache_with_parameter_env_start_close_door_ptr = _OpCache_env_start_close_door.find(param); - if(_OpCache_with_parameter_env_start_close_door_ptr == _OpCache_env_start_close_door.end()) { + } else { + std::unordered_map<LandingGear_R6::_ProjectionRead_env_start_close_door, LandingGear_R6::_ProjectionWrite_env_start_close_door, LandingGear_R6::_ProjectionRead_env_start_close_door::Hash, LandingGear_R6::_ProjectionRead_env_start_close_door::HashEqual> _OpCache_with_parameter_env_start_close_door = _OpCache_with_parameter_env_start_close_door_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_env_start_close_door.find(readState); + if(writeState_ptr != _OpCache_with_parameter_env_start_close_door.end()) { + LandingGear_R6::_ProjectionWrite_env_start_close_door writeState = writeState_ptr->second; + copiedState._apply_update_for_env_start_close_door(writeState); + } else { copiedState.env_start_close_door(_tmp_1); LandingGear_R6::_ProjectionWrite_env_start_close_door writeState = copiedState._update_for_env_start_close_door(); - std::unordered_map<LandingGear_R6::_ProjectionRead_env_start_close_door, LandingGear_R6::_ProjectionWrite_env_start_close_door, LandingGear_R6::_ProjectionRead_env_start_close_door::Hash, LandingGear_R6::_ProjectionRead_env_start_close_door::HashEqual> _OpCache_with_parameter_env_start_close_door; - _OpCache_with_parameter_env_start_close_door.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_env_start_close_door_lock(_ProjectionRead_env_start_close_door_mutex); - _OpCache_env_start_close_door.insert({param, _OpCache_with_parameter_env_start_close_door}); - } - - } else { - std::unordered_map<LandingGear_R6::_ProjectionRead_env_start_close_door, LandingGear_R6::_ProjectionWrite_env_start_close_door, LandingGear_R6::_ProjectionRead_env_start_close_door::Hash, LandingGear_R6::_ProjectionRead_env_start_close_door::HashEqual> _OpCache_with_parameter_env_start_close_door = _OpCache_with_parameter_env_start_close_door_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_env_start_close_door.find(readState); - if(writeState_ptr != _OpCache_with_parameter_env_start_close_door.end()) { - LandingGear_R6::_ProjectionWrite_env_start_close_door writeState = writeState_ptr->second; - copiedState._apply_update_for_env_start_close_door(writeState); - } else { - copiedState.env_start_close_door(_tmp_1); - LandingGear_R6::_ProjectionWrite_env_start_close_door writeState = copiedState._update_for_env_start_close_door(); - { - std::unique_lock<std::mutex> _ProjectionRead_env_start_close_door_lock(_ProjectionRead_env_start_close_door_mutex); - _OpCache_with_parameter_env_start_close_door.insert({readState, writeState}); - } + _OpCache_with_parameter_env_start_close_door.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "env_start_close_door"; - result.insert(copiedState); + copiedState.stateAccessedVia = "env_start_close_door"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } LandingGear_R6::_ProjectionRead__tr_env_close_door read__tr_env_close_door_state = state._projected_state_for__tr_env_close_door(); + BSet<LandingGear_R6::POSITION> _trid_29; auto _trid_29_ptr = _OpCache_tr_env_close_door.find(read__tr_env_close_door_state); if(_trid_29_ptr == _OpCache_tr_env_close_door.end()) { - BSet<LandingGear_R6::POSITION> _trid_29 = state._tr_env_close_door(); + _trid_29 = state._tr_env_close_door(); { std::unique_lock<std::mutex> _ProjectionRead__tr_env_close_door_lock(_ProjectionRead__tr_env_close_door_mutex); _OpCache_tr_env_close_door.insert({read__tr_env_close_door_state, _trid_29}); } - for(const LandingGear_R6::POSITION& param : _trid_29) { - LandingGear_R6::POSITION _tmp_1 = param; - - LandingGear_R6 copiedState = state._copy(); - LandingGear_R6::_ProjectionRead_env_close_door readState = state._projected_state_for_env_close_door(); + } else { + _trid_29 = _trid_29_ptr->second; + } - auto _OpCache_with_parameter_env_close_door_ptr = _OpCache_env_close_door.find(param); - if(_OpCache_with_parameter_env_close_door_ptr == _OpCache_env_close_door.end()) { - copiedState.env_close_door(_tmp_1); - LandingGear_R6::_ProjectionWrite_env_close_door writeState = copiedState._update_for_env_close_door(); - std::unordered_map<LandingGear_R6::_ProjectionRead_env_close_door, LandingGear_R6::_ProjectionWrite_env_close_door, LandingGear_R6::_ProjectionRead_env_close_door::Hash, LandingGear_R6::_ProjectionRead_env_close_door::HashEqual> _OpCache_with_parameter_env_close_door; - _OpCache_with_parameter_env_close_door.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_env_close_door_lock(_ProjectionRead_env_close_door_mutex); - _OpCache_env_close_door.insert({param, _OpCache_with_parameter_env_close_door}); - } + for(const LandingGear_R6::POSITION& param : _trid_29) { + LandingGear_R6::POSITION _tmp_1 = param; - } else { - std::unordered_map<LandingGear_R6::_ProjectionRead_env_close_door, LandingGear_R6::_ProjectionWrite_env_close_door, LandingGear_R6::_ProjectionRead_env_close_door::Hash, LandingGear_R6::_ProjectionRead_env_close_door::HashEqual> _OpCache_with_parameter_env_close_door = _OpCache_with_parameter_env_close_door_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_env_close_door.find(readState); - if(writeState_ptr != _OpCache_with_parameter_env_close_door.end()) { - LandingGear_R6::_ProjectionWrite_env_close_door writeState = writeState_ptr->second; - copiedState._apply_update_for_env_close_door(writeState); - } else { - copiedState.env_close_door(_tmp_1); - LandingGear_R6::_ProjectionWrite_env_close_door writeState = copiedState._update_for_env_close_door(); - { - std::unique_lock<std::mutex> _ProjectionRead_env_close_door_lock(_ProjectionRead_env_close_door_mutex); - _OpCache_with_parameter_env_close_door.insert({readState, writeState}); - } - } + LandingGear_R6 copiedState = state._copy(); + LandingGear_R6::_ProjectionRead_env_close_door readState = state._projected_state_for_env_close_door(); + + auto _OpCache_with_parameter_env_close_door_ptr = _OpCache_env_close_door.find(param); + if(_OpCache_with_parameter_env_close_door_ptr == _OpCache_env_close_door.end()) { + copiedState.env_close_door(_tmp_1); + LandingGear_R6::_ProjectionWrite_env_close_door writeState = copiedState._update_for_env_close_door(); + std::unordered_map<LandingGear_R6::_ProjectionRead_env_close_door, LandingGear_R6::_ProjectionWrite_env_close_door, LandingGear_R6::_ProjectionRead_env_close_door::Hash, LandingGear_R6::_ProjectionRead_env_close_door::HashEqual> _OpCache_with_parameter_env_close_door; + _OpCache_with_parameter_env_close_door.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_env_close_door_lock(_ProjectionRead_env_close_door_mutex); + _OpCache_env_close_door.insert({param, _OpCache_with_parameter_env_close_door}); } - copiedState.stateAccessedVia = "env_close_door"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<LandingGear_R6::POSITION> _trid_29 = _trid_29_ptr->second; - for(const LandingGear_R6::POSITION& param : _trid_29) { - LandingGear_R6::POSITION _tmp_1 = param; - - LandingGear_R6 copiedState = state._copy(); - LandingGear_R6::_ProjectionRead_env_close_door readState = state._projected_state_for_env_close_door(); - - auto _OpCache_with_parameter_env_close_door_ptr = _OpCache_env_close_door.find(param); - if(_OpCache_with_parameter_env_close_door_ptr == _OpCache_env_close_door.end()) { + } else { + std::unordered_map<LandingGear_R6::_ProjectionRead_env_close_door, LandingGear_R6::_ProjectionWrite_env_close_door, LandingGear_R6::_ProjectionRead_env_close_door::Hash, LandingGear_R6::_ProjectionRead_env_close_door::HashEqual> _OpCache_with_parameter_env_close_door = _OpCache_with_parameter_env_close_door_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_env_close_door.find(readState); + if(writeState_ptr != _OpCache_with_parameter_env_close_door.end()) { + LandingGear_R6::_ProjectionWrite_env_close_door writeState = writeState_ptr->second; + copiedState._apply_update_for_env_close_door(writeState); + } else { copiedState.env_close_door(_tmp_1); LandingGear_R6::_ProjectionWrite_env_close_door writeState = copiedState._update_for_env_close_door(); - std::unordered_map<LandingGear_R6::_ProjectionRead_env_close_door, LandingGear_R6::_ProjectionWrite_env_close_door, LandingGear_R6::_ProjectionRead_env_close_door::Hash, LandingGear_R6::_ProjectionRead_env_close_door::HashEqual> _OpCache_with_parameter_env_close_door; - _OpCache_with_parameter_env_close_door.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_env_close_door_lock(_ProjectionRead_env_close_door_mutex); - _OpCache_env_close_door.insert({param, _OpCache_with_parameter_env_close_door}); - } - - } else { - std::unordered_map<LandingGear_R6::_ProjectionRead_env_close_door, LandingGear_R6::_ProjectionWrite_env_close_door, LandingGear_R6::_ProjectionRead_env_close_door::Hash, LandingGear_R6::_ProjectionRead_env_close_door::HashEqual> _OpCache_with_parameter_env_close_door = _OpCache_with_parameter_env_close_door_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_env_close_door.find(readState); - if(writeState_ptr != _OpCache_with_parameter_env_close_door.end()) { - LandingGear_R6::_ProjectionWrite_env_close_door writeState = writeState_ptr->second; - copiedState._apply_update_for_env_close_door(writeState); - } else { - copiedState.env_close_door(_tmp_1); - LandingGear_R6::_ProjectionWrite_env_close_door writeState = copiedState._update_for_env_close_door(); - { - std::unique_lock<std::mutex> _ProjectionRead_env_close_door_lock(_ProjectionRead_env_close_door_mutex); - _OpCache_with_parameter_env_close_door.insert({readState, writeState}); - } + _OpCache_with_parameter_env_close_door.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "env_close_door"; - result.insert(copiedState); + copiedState.stateAccessedVia = "env_close_door"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } LandingGear_R6::_ProjectionRead__tr_env_close_door_skip read__tr_env_close_door_skip_state = state._projected_state_for__tr_env_close_door_skip(); + BSet<LandingGear_R6::POSITION> _trid_30; auto _trid_30_ptr = _OpCache_tr_env_close_door_skip.find(read__tr_env_close_door_skip_state); if(_trid_30_ptr == _OpCache_tr_env_close_door_skip.end()) { - BSet<LandingGear_R6::POSITION> _trid_30 = state._tr_env_close_door_skip(); + _trid_30 = state._tr_env_close_door_skip(); { std::unique_lock<std::mutex> _ProjectionRead__tr_env_close_door_skip_lock(_ProjectionRead__tr_env_close_door_skip_mutex); _OpCache_tr_env_close_door_skip.insert({read__tr_env_close_door_skip_state, _trid_30}); } - for(const LandingGear_R6::POSITION& param : _trid_30) { - LandingGear_R6::POSITION _tmp_1 = param; - - LandingGear_R6 copiedState = state._copy(); - LandingGear_R6::_ProjectionRead_env_close_door_skip readState = state._projected_state_for_env_close_door_skip(); + } else { + _trid_30 = _trid_30_ptr->second; + } - auto _OpCache_with_parameter_env_close_door_skip_ptr = _OpCache_env_close_door_skip.find(param); - if(_OpCache_with_parameter_env_close_door_skip_ptr == _OpCache_env_close_door_skip.end()) { - copiedState.env_close_door_skip(_tmp_1); - LandingGear_R6::_ProjectionWrite_env_close_door_skip writeState = copiedState._update_for_env_close_door_skip(); - std::unordered_map<LandingGear_R6::_ProjectionRead_env_close_door_skip, LandingGear_R6::_ProjectionWrite_env_close_door_skip, LandingGear_R6::_ProjectionRead_env_close_door_skip::Hash, LandingGear_R6::_ProjectionRead_env_close_door_skip::HashEqual> _OpCache_with_parameter_env_close_door_skip; - _OpCache_with_parameter_env_close_door_skip.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_env_close_door_skip_lock(_ProjectionRead_env_close_door_skip_mutex); - _OpCache_env_close_door_skip.insert({param, _OpCache_with_parameter_env_close_door_skip}); - } + for(const LandingGear_R6::POSITION& param : _trid_30) { + LandingGear_R6::POSITION _tmp_1 = param; - } else { - std::unordered_map<LandingGear_R6::_ProjectionRead_env_close_door_skip, LandingGear_R6::_ProjectionWrite_env_close_door_skip, LandingGear_R6::_ProjectionRead_env_close_door_skip::Hash, LandingGear_R6::_ProjectionRead_env_close_door_skip::HashEqual> _OpCache_with_parameter_env_close_door_skip = _OpCache_with_parameter_env_close_door_skip_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_env_close_door_skip.find(readState); - if(writeState_ptr != _OpCache_with_parameter_env_close_door_skip.end()) { - LandingGear_R6::_ProjectionWrite_env_close_door_skip writeState = writeState_ptr->second; - copiedState._apply_update_for_env_close_door_skip(writeState); - } else { - copiedState.env_close_door_skip(_tmp_1); - LandingGear_R6::_ProjectionWrite_env_close_door_skip writeState = copiedState._update_for_env_close_door_skip(); - { - std::unique_lock<std::mutex> _ProjectionRead_env_close_door_skip_lock(_ProjectionRead_env_close_door_skip_mutex); - _OpCache_with_parameter_env_close_door_skip.insert({readState, writeState}); - } - } + LandingGear_R6 copiedState = state._copy(); + LandingGear_R6::_ProjectionRead_env_close_door_skip readState = state._projected_state_for_env_close_door_skip(); + + auto _OpCache_with_parameter_env_close_door_skip_ptr = _OpCache_env_close_door_skip.find(param); + if(_OpCache_with_parameter_env_close_door_skip_ptr == _OpCache_env_close_door_skip.end()) { + copiedState.env_close_door_skip(_tmp_1); + LandingGear_R6::_ProjectionWrite_env_close_door_skip writeState = copiedState._update_for_env_close_door_skip(); + std::unordered_map<LandingGear_R6::_ProjectionRead_env_close_door_skip, LandingGear_R6::_ProjectionWrite_env_close_door_skip, LandingGear_R6::_ProjectionRead_env_close_door_skip::Hash, LandingGear_R6::_ProjectionRead_env_close_door_skip::HashEqual> _OpCache_with_parameter_env_close_door_skip; + _OpCache_with_parameter_env_close_door_skip.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_env_close_door_skip_lock(_ProjectionRead_env_close_door_skip_mutex); + _OpCache_env_close_door_skip.insert({param, _OpCache_with_parameter_env_close_door_skip}); } - copiedState.stateAccessedVia = "env_close_door_skip"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<LandingGear_R6::POSITION> _trid_30 = _trid_30_ptr->second; - for(const LandingGear_R6::POSITION& param : _trid_30) { - LandingGear_R6::POSITION _tmp_1 = param; - - LandingGear_R6 copiedState = state._copy(); - LandingGear_R6::_ProjectionRead_env_close_door_skip readState = state._projected_state_for_env_close_door_skip(); - - auto _OpCache_with_parameter_env_close_door_skip_ptr = _OpCache_env_close_door_skip.find(param); - if(_OpCache_with_parameter_env_close_door_skip_ptr == _OpCache_env_close_door_skip.end()) { + } else { + std::unordered_map<LandingGear_R6::_ProjectionRead_env_close_door_skip, LandingGear_R6::_ProjectionWrite_env_close_door_skip, LandingGear_R6::_ProjectionRead_env_close_door_skip::Hash, LandingGear_R6::_ProjectionRead_env_close_door_skip::HashEqual> _OpCache_with_parameter_env_close_door_skip = _OpCache_with_parameter_env_close_door_skip_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_env_close_door_skip.find(readState); + if(writeState_ptr != _OpCache_with_parameter_env_close_door_skip.end()) { + LandingGear_R6::_ProjectionWrite_env_close_door_skip writeState = writeState_ptr->second; + copiedState._apply_update_for_env_close_door_skip(writeState); + } else { copiedState.env_close_door_skip(_tmp_1); LandingGear_R6::_ProjectionWrite_env_close_door_skip writeState = copiedState._update_for_env_close_door_skip(); - std::unordered_map<LandingGear_R6::_ProjectionRead_env_close_door_skip, LandingGear_R6::_ProjectionWrite_env_close_door_skip, LandingGear_R6::_ProjectionRead_env_close_door_skip::Hash, LandingGear_R6::_ProjectionRead_env_close_door_skip::HashEqual> _OpCache_with_parameter_env_close_door_skip; - _OpCache_with_parameter_env_close_door_skip.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_env_close_door_skip_lock(_ProjectionRead_env_close_door_skip_mutex); - _OpCache_env_close_door_skip.insert({param, _OpCache_with_parameter_env_close_door_skip}); - } - - } else { - std::unordered_map<LandingGear_R6::_ProjectionRead_env_close_door_skip, LandingGear_R6::_ProjectionWrite_env_close_door_skip, LandingGear_R6::_ProjectionRead_env_close_door_skip::Hash, LandingGear_R6::_ProjectionRead_env_close_door_skip::HashEqual> _OpCache_with_parameter_env_close_door_skip = _OpCache_with_parameter_env_close_door_skip_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_env_close_door_skip.find(readState); - if(writeState_ptr != _OpCache_with_parameter_env_close_door_skip.end()) { - LandingGear_R6::_ProjectionWrite_env_close_door_skip writeState = writeState_ptr->second; - copiedState._apply_update_for_env_close_door_skip(writeState); - } else { - copiedState.env_close_door_skip(_tmp_1); - LandingGear_R6::_ProjectionWrite_env_close_door_skip writeState = copiedState._update_for_env_close_door_skip(); - { - std::unique_lock<std::mutex> _ProjectionRead_env_close_door_skip_lock(_ProjectionRead_env_close_door_skip_mutex); - _OpCache_with_parameter_env_close_door_skip.insert({readState, writeState}); - } + _OpCache_with_parameter_env_close_door_skip.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "env_close_door_skip"; - result.insert(copiedState); + copiedState.stateAccessedVia = "env_close_door_skip"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } @@ -12486,7 +12164,10 @@ class ModelChecker { copiedState.stateAccessedVia = "toggle_handle_up"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } LandingGear_R6::_ProjectionRead__tr_toggle_handle_down read__tr_toggle_handle_down_state = state._projected_state_for__tr_toggle_handle_down(); bool _trid_32; @@ -12533,7 +12214,10 @@ class ModelChecker { copiedState.stateAccessedVia = "toggle_handle_down"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } LandingGear_R6::_ProjectionRead__tr_con_stimulate_general_valve read__tr_con_stimulate_general_valve_state = state._projected_state_for__tr_con_stimulate_general_valve(); bool _trid_33; @@ -12580,7 +12264,10 @@ class ModelChecker { copiedState.stateAccessedVia = "con_stimulate_general_valve"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } LandingGear_R6::_ProjectionRead__tr_con_stop_stimulate_general_valve read__tr_con_stop_stimulate_general_valve_state = state._projected_state_for__tr_con_stop_stimulate_general_valve(); bool _trid_34; @@ -12627,7 +12314,10 @@ class ModelChecker { copiedState.stateAccessedVia = "con_stop_stimulate_general_valve"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } LandingGear_R6::_ProjectionRead__tr_evn_open_general_valve read__tr_evn_open_general_valve_state = state._projected_state_for__tr_evn_open_general_valve(); bool _trid_35; @@ -12674,7 +12364,10 @@ class ModelChecker { copiedState.stateAccessedVia = "evn_open_general_valve"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } LandingGear_R6::_ProjectionRead__tr_evn_close_general_valve read__tr_evn_close_general_valve_state = state._projected_state_for__tr_evn_close_general_valve(); bool _trid_36; @@ -12721,7 +12414,10 @@ class ModelChecker { copiedState.stateAccessedVia = "evn_close_general_valve"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } LandingGear_R6::_ProjectionRead__tr_env_close_analogical_switch read__tr_env_close_analogical_switch_state = state._projected_state_for__tr_env_close_analogical_switch(); bool _trid_37; @@ -12768,7 +12464,10 @@ class ModelChecker { copiedState.stateAccessedVia = "env_close_analogical_switch"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } LandingGear_R6::_ProjectionRead__tr_env_open_analogical_switch read__tr_env_open_analogical_switch_state = state._projected_state_for__tr_env_open_analogical_switch(); bool _trid_38; @@ -12815,7 +12514,10 @@ class ModelChecker { copiedState.stateAccessedVia = "env_open_analogical_switch"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } } else { @@ -12824,126 +12526,180 @@ class ModelChecker { copiedState.begin_flying(); copiedState.stateAccessedVia = "begin_flying"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } if(state._tr_land_plane()) { LandingGear_R6 copiedState = state._copy(); copiedState.land_plane(); copiedState.stateAccessedVia = "land_plane"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } if(state._tr_open_valve_door_open()) { LandingGear_R6 copiedState = state._copy(); copiedState.open_valve_door_open(); copiedState.stateAccessedVia = "open_valve_door_open"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } if(state._tr_close_valve_door_open()) { LandingGear_R6 copiedState = state._copy(); copiedState.close_valve_door_open(); copiedState.stateAccessedVia = "close_valve_door_open"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } if(state._tr_open_valve_door_close()) { LandingGear_R6 copiedState = state._copy(); copiedState.open_valve_door_close(); copiedState.stateAccessedVia = "open_valve_door_close"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } if(state._tr_close_valve_door_close()) { LandingGear_R6 copiedState = state._copy(); copiedState.close_valve_door_close(); copiedState.stateAccessedVia = "close_valve_door_close"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } if(state._tr_open_valve_retract_gear()) { LandingGear_R6 copiedState = state._copy(); copiedState.open_valve_retract_gear(); copiedState.stateAccessedVia = "open_valve_retract_gear"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } if(state._tr_close_valve_retract_gear()) { LandingGear_R6 copiedState = state._copy(); copiedState.close_valve_retract_gear(); copiedState.stateAccessedVia = "close_valve_retract_gear"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } if(state._tr_open_valve_extend_gear()) { LandingGear_R6 copiedState = state._copy(); copiedState.open_valve_extend_gear(); copiedState.stateAccessedVia = "open_valve_extend_gear"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } if(state._tr_close_valve_extend_gear()) { LandingGear_R6 copiedState = state._copy(); copiedState.close_valve_extend_gear(); copiedState.stateAccessedVia = "close_valve_extend_gear"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } if(state._tr_con_stimulate_open_door_valve()) { LandingGear_R6 copiedState = state._copy(); copiedState.con_stimulate_open_door_valve(); copiedState.stateAccessedVia = "con_stimulate_open_door_valve"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } if(state._tr_con_stop_stimulate_open_door_valve()) { LandingGear_R6 copiedState = state._copy(); copiedState.con_stop_stimulate_open_door_valve(); copiedState.stateAccessedVia = "con_stop_stimulate_open_door_valve"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } if(state._tr_con_stimulate_close_door_valve()) { LandingGear_R6 copiedState = state._copy(); copiedState.con_stimulate_close_door_valve(); copiedState.stateAccessedVia = "con_stimulate_close_door_valve"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } if(state._tr_con_stop_stimulate_close_door_valve()) { LandingGear_R6 copiedState = state._copy(); copiedState.con_stop_stimulate_close_door_valve(); copiedState.stateAccessedVia = "con_stop_stimulate_close_door_valve"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } if(state._tr_con_stimulate_retract_gear_valve()) { LandingGear_R6 copiedState = state._copy(); copiedState.con_stimulate_retract_gear_valve(); copiedState.stateAccessedVia = "con_stimulate_retract_gear_valve"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } if(state._tr_con_stop_stimulate_retract_gear_valve()) { LandingGear_R6 copiedState = state._copy(); copiedState.con_stop_stimulate_retract_gear_valve(); copiedState.stateAccessedVia = "con_stop_stimulate_retract_gear_valve"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } if(state._tr_con_stimulate_extend_gear_valve()) { LandingGear_R6 copiedState = state._copy(); copiedState.con_stimulate_extend_gear_valve(); copiedState.stateAccessedVia = "con_stimulate_extend_gear_valve"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } if(state._tr_con_stop_stimulate_extend_gear_valve()) { LandingGear_R6 copiedState = state._copy(); copiedState.con_stop_stimulate_extend_gear_valve(); copiedState.stateAccessedVia = "con_stop_stimulate_extend_gear_valve"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<LandingGear_R6::POSITION> _trid_19 = state._tr_env_start_retracting_first(); for(const LandingGear_R6::POSITION& param : _trid_19) { @@ -12953,7 +12709,10 @@ class ModelChecker { copiedState.env_start_retracting_first(_tmp_1); copiedState.stateAccessedVia = "env_start_retracting_first"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<LandingGear_R6::POSITION> _trid_20 = state._tr_env_retract_gear_skip(); for(const LandingGear_R6::POSITION& param : _trid_20) { @@ -12963,7 +12722,10 @@ class ModelChecker { copiedState.env_retract_gear_skip(_tmp_1); copiedState.stateAccessedVia = "env_retract_gear_skip"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<LandingGear_R6::POSITION> _trid_21 = state._tr_env_retract_gear_last(); for(const LandingGear_R6::POSITION& param : _trid_21) { @@ -12973,7 +12735,10 @@ class ModelChecker { copiedState.env_retract_gear_last(_tmp_1); copiedState.stateAccessedVia = "env_retract_gear_last"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<LandingGear_R6::POSITION> _trid_22 = state._tr_env_start_extending(); for(const LandingGear_R6::POSITION& param : _trid_22) { @@ -12983,7 +12748,10 @@ class ModelChecker { copiedState.env_start_extending(_tmp_1); copiedState.stateAccessedVia = "env_start_extending"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<LandingGear_R6::POSITION> _trid_23 = state._tr_env_extend_gear_last(); for(const LandingGear_R6::POSITION& param : _trid_23) { @@ -12993,7 +12761,10 @@ class ModelChecker { copiedState.env_extend_gear_last(_tmp_1); copiedState.stateAccessedVia = "env_extend_gear_last"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<LandingGear_R6::POSITION> _trid_24 = state._tr_env_extend_gear_skip(); for(const LandingGear_R6::POSITION& param : _trid_24) { @@ -13003,7 +12774,10 @@ class ModelChecker { copiedState.env_extend_gear_skip(_tmp_1); copiedState.stateAccessedVia = "env_extend_gear_skip"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<LandingGear_R6::POSITION> _trid_25 = state._tr_env_start_open_door(); for(const LandingGear_R6::POSITION& param : _trid_25) { @@ -13013,7 +12787,10 @@ class ModelChecker { copiedState.env_start_open_door(_tmp_1); copiedState.stateAccessedVia = "env_start_open_door"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<LandingGear_R6::POSITION> _trid_26 = state._tr_env_open_door_last(); for(const LandingGear_R6::POSITION& param : _trid_26) { @@ -13023,7 +12800,10 @@ class ModelChecker { copiedState.env_open_door_last(_tmp_1); copiedState.stateAccessedVia = "env_open_door_last"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<LandingGear_R6::POSITION> _trid_27 = state._tr_env_open_door_skip(); for(const LandingGear_R6::POSITION& param : _trid_27) { @@ -13033,7 +12813,10 @@ class ModelChecker { copiedState.env_open_door_skip(_tmp_1); copiedState.stateAccessedVia = "env_open_door_skip"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<LandingGear_R6::POSITION> _trid_28 = state._tr_env_start_close_door(); for(const LandingGear_R6::POSITION& param : _trid_28) { @@ -13043,7 +12826,10 @@ class ModelChecker { copiedState.env_start_close_door(_tmp_1); copiedState.stateAccessedVia = "env_start_close_door"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<LandingGear_R6::POSITION> _trid_29 = state._tr_env_close_door(); for(const LandingGear_R6::POSITION& param : _trid_29) { @@ -13053,7 +12839,10 @@ class ModelChecker { copiedState.env_close_door(_tmp_1); copiedState.stateAccessedVia = "env_close_door"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<LandingGear_R6::POSITION> _trid_30 = state._tr_env_close_door_skip(); for(const LandingGear_R6::POSITION& param : _trid_30) { @@ -13063,63 +12852,90 @@ class ModelChecker { copiedState.env_close_door_skip(_tmp_1); copiedState.stateAccessedVia = "env_close_door_skip"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } if(state._tr_toggle_handle_up()) { LandingGear_R6 copiedState = state._copy(); copiedState.toggle_handle_up(); copiedState.stateAccessedVia = "toggle_handle_up"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } if(state._tr_toggle_handle_down()) { LandingGear_R6 copiedState = state._copy(); copiedState.toggle_handle_down(); copiedState.stateAccessedVia = "toggle_handle_down"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } if(state._tr_con_stimulate_general_valve()) { LandingGear_R6 copiedState = state._copy(); copiedState.con_stimulate_general_valve(); copiedState.stateAccessedVia = "con_stimulate_general_valve"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } if(state._tr_con_stop_stimulate_general_valve()) { LandingGear_R6 copiedState = state._copy(); copiedState.con_stop_stimulate_general_valve(); copiedState.stateAccessedVia = "con_stop_stimulate_general_valve"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } if(state._tr_evn_open_general_valve()) { LandingGear_R6 copiedState = state._copy(); copiedState.evn_open_general_valve(); copiedState.stateAccessedVia = "evn_open_general_valve"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } if(state._tr_evn_close_general_valve()) { LandingGear_R6 copiedState = state._copy(); copiedState.evn_close_general_valve(); copiedState.stateAccessedVia = "evn_close_general_valve"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } if(state._tr_env_close_analogical_switch()) { LandingGear_R6 copiedState = state._copy(); copiedState.env_close_analogical_switch(); copiedState.stateAccessedVia = "env_close_analogical_switch"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } if(state._tr_env_open_analogical_switch()) { LandingGear_R6 copiedState = state._copy(); copiedState.env_open_analogical_switch(); copiedState.stateAccessedVia = "env_open_analogical_switch"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } } diff --git a/benchmarks/model_checking_opreuse/C++/Lift_MC_Large.cpp b/benchmarks/model_checking_opreuse/C++/Lift_MC_Large.cpp index 65e280dbc615204af6ab20dd50c8faa946d01db1..4f184f8960bbf5c353a7844491fb462b63bb812f 100644 --- a/benchmarks/model_checking_opreuse/C++/Lift_MC_Large.cpp +++ b/benchmarks/model_checking_opreuse/C++/Lift_MC_Large.cpp @@ -10,7 +10,6 @@ #include <atomic> #include <any> #include <mutex> -#include <shared_mutex> #include <future> #include <boost/asio/post.hpp> #include <boost/asio/thread_pool.hpp> @@ -680,12 +679,16 @@ class ModelChecker { states.insert(machine); unvisitedStates.push_back(machine); - std::atomic<bool> stopThreads(false); + std::atomic<bool> stopThreads; + stopThreads = false; std::atomic<int> possibleQueueChanges; possibleQueueChanges = 0; - while(!unvisitedStates.empty() && !stopThreads.load()) { - possibleQueueChanges.fetch_add(1); + std::atomic<bool> waitFlag; + waitFlag = true; + + while(!unvisitedStates.empty() && !stopThreads) { + possibleQueueChanges += 1; Lift_MC_Large state = next(); std::packaged_task<void()> task([&, state] { std::unordered_set<Lift_MC_Large, Lift_MC_Large::Hash, Lift_MC_Large::HashEqual> nextStates = generateNextStates(state); @@ -706,12 +709,14 @@ class ModelChecker { } } - possibleQueueChanges.fetch_sub(1); { std::unique_lock<std::mutex> lock(mutex); - if (!unvisitedStates.empty() || possibleQueueChanges.load() == 0) { + possibleQueueChanges -= 1; + int running = possibleQueueChanges; + if (!unvisitedStates.empty() || running == 0) { { std::unique_lock<std::mutex> lock(waitMutex); + waitFlag = false; waitCV.notify_one(); } } @@ -721,24 +726,27 @@ class ModelChecker { if(invariantViolated(state)) { invariantViolatedBool = true; counterExampleState = state; - stopThreads.store(true); + stopThreads = true; } if(nextStates.empty()) { deadlockDetected = true; counterExampleState = state; - stopThreads.store(true); + stopThreads = true; } }); + waitFlag = true; boost::asio::post(workers, std::move(task)); { std::unique_lock<std::mutex> lock(waitMutex); - waitCV.wait(lock, [&] { - return !unvisitedStates.empty() || possibleQueueChanges == 0; - }); + if(unvisitedStates.empty() && possibleQueueChanges > 0) { + waitCV.wait(lock, [&] { + return waitFlag == false; + }); + } } } workers.join(); @@ -827,7 +835,10 @@ class ModelChecker { copiedState.stateAccessedVia = "inc"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } Lift_MC_Large::_ProjectionRead__tr_dec read__tr_dec_state = state._projected_state_for__tr_dec(); bool _trid_2; @@ -874,7 +885,10 @@ class ModelChecker { copiedState.stateAccessedVia = "dec"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } } else { @@ -883,14 +897,20 @@ class ModelChecker { copiedState.inc(); copiedState.stateAccessedVia = "inc"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } if(state._tr_dec()) { Lift_MC_Large copiedState = state._copy(); copiedState.dec(); copiedState.stateAccessedVia = "dec"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } } diff --git a/benchmarks/model_checking_opreuse/C++/QueensWithEvents_4.cpp b/benchmarks/model_checking_opreuse/C++/QueensWithEvents_4.cpp index 24e0fd57581f27fcb0ae0a808e1e790e5e5de4dc..1104e37cfad9efc171b1c56a1284ef9a33dc107a 100644 --- a/benchmarks/model_checking_opreuse/C++/QueensWithEvents_4.cpp +++ b/benchmarks/model_checking_opreuse/C++/QueensWithEvents_4.cpp @@ -10,7 +10,6 @@ #include <atomic> #include <any> #include <mutex> -#include <shared_mutex> #include <future> #include <boost/asio/post.hpp> #include <boost/asio/thread_pool.hpp> @@ -510,12 +509,16 @@ class ModelChecker { states.insert(machine); unvisitedStates.push_back(machine); - std::atomic<bool> stopThreads(false); + std::atomic<bool> stopThreads; + stopThreads = false; std::atomic<int> possibleQueueChanges; possibleQueueChanges = 0; - while(!unvisitedStates.empty() && !stopThreads.load()) { - possibleQueueChanges.fetch_add(1); + std::atomic<bool> waitFlag; + waitFlag = true; + + while(!unvisitedStates.empty() && !stopThreads) { + possibleQueueChanges += 1; QueensWithEvents_4 state = next(); std::packaged_task<void()> task([&, state] { std::unordered_set<QueensWithEvents_4, QueensWithEvents_4::Hash, QueensWithEvents_4::HashEqual> nextStates = generateNextStates(state); @@ -536,12 +539,14 @@ class ModelChecker { } } - possibleQueueChanges.fetch_sub(1); { std::unique_lock<std::mutex> lock(mutex); - if (!unvisitedStates.empty() || possibleQueueChanges.load() == 0) { + possibleQueueChanges -= 1; + int running = possibleQueueChanges; + if (!unvisitedStates.empty() || running == 0) { { std::unique_lock<std::mutex> lock(waitMutex); + waitFlag = false; waitCV.notify_one(); } } @@ -551,24 +556,27 @@ class ModelChecker { if(invariantViolated(state)) { invariantViolatedBool = true; counterExampleState = state; - stopThreads.store(true); + stopThreads = true; } if(nextStates.empty()) { deadlockDetected = true; counterExampleState = state; - stopThreads.store(true); + stopThreads = true; } }); + waitFlag = true; boost::asio::post(workers, std::move(task)); { std::unique_lock<std::mutex> lock(waitMutex); - waitCV.wait(lock, [&] { - return !unvisitedStates.empty() || possibleQueueChanges == 0; - }); + if(unvisitedStates.empty() && possibleQueueChanges > 0) { + waitCV.wait(lock, [&] { + return waitFlag == false; + }); + } } } workers.join(); @@ -613,87 +621,55 @@ class ModelChecker { std::unordered_set<QueensWithEvents_4, QueensWithEvents_4::Hash, QueensWithEvents_4::HashEqual> result = std::unordered_set<QueensWithEvents_4, QueensWithEvents_4::Hash, QueensWithEvents_4::HashEqual>(); if(isCaching) { QueensWithEvents_4::_ProjectionRead__tr_Solve read__tr_Solve_state = state._projected_state_for__tr_Solve(); + BSet<BRelation<BInteger, BInteger >> _trid_1; auto _trid_1_ptr = _OpCache_tr_Solve.find(read__tr_Solve_state); if(_trid_1_ptr == _OpCache_tr_Solve.end()) { - BSet<BRelation<BInteger, BInteger >> _trid_1 = state._tr_Solve(); + _trid_1 = state._tr_Solve(); { std::unique_lock<std::mutex> _ProjectionRead__tr_Solve_lock(_ProjectionRead__tr_Solve_mutex); _OpCache_tr_Solve.insert({read__tr_Solve_state, _trid_1}); } - for(const BRelation<BInteger, BInteger >& param : _trid_1) { - BRelation<BInteger, BInteger > _tmp_1 = param; - - QueensWithEvents_4 copiedState = state._copy(); - QueensWithEvents_4::_ProjectionRead_Solve readState = state._projected_state_for_Solve(); + } else { + _trid_1 = _trid_1_ptr->second; + } - auto _OpCache_with_parameter_Solve_ptr = _OpCache_Solve.find(param); - if(_OpCache_with_parameter_Solve_ptr == _OpCache_Solve.end()) { - copiedState.Solve(_tmp_1); - QueensWithEvents_4::_ProjectionWrite_Solve writeState = copiedState._update_for_Solve(); - std::unordered_map<QueensWithEvents_4::_ProjectionRead_Solve, QueensWithEvents_4::_ProjectionWrite_Solve, QueensWithEvents_4::_ProjectionRead_Solve::Hash, QueensWithEvents_4::_ProjectionRead_Solve::HashEqual> _OpCache_with_parameter_Solve; - _OpCache_with_parameter_Solve.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_Solve_lock(_ProjectionRead_Solve_mutex); - _OpCache_Solve.insert({param, _OpCache_with_parameter_Solve}); - } + for(const BRelation<BInteger, BInteger >& param : _trid_1) { + BRelation<BInteger, BInteger > _tmp_1 = param; - } else { - std::unordered_map<QueensWithEvents_4::_ProjectionRead_Solve, QueensWithEvents_4::_ProjectionWrite_Solve, QueensWithEvents_4::_ProjectionRead_Solve::Hash, QueensWithEvents_4::_ProjectionRead_Solve::HashEqual> _OpCache_with_parameter_Solve = _OpCache_with_parameter_Solve_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_Solve.find(readState); - if(writeState_ptr != _OpCache_with_parameter_Solve.end()) { - QueensWithEvents_4::_ProjectionWrite_Solve writeState = writeState_ptr->second; - copiedState._apply_update_for_Solve(writeState); - } else { - copiedState.Solve(_tmp_1); - QueensWithEvents_4::_ProjectionWrite_Solve writeState = copiedState._update_for_Solve(); - { - std::unique_lock<std::mutex> _ProjectionRead_Solve_lock(_ProjectionRead_Solve_mutex); - _OpCache_with_parameter_Solve.insert({readState, writeState}); - } - } + QueensWithEvents_4 copiedState = state._copy(); + QueensWithEvents_4::_ProjectionRead_Solve readState = state._projected_state_for_Solve(); + + auto _OpCache_with_parameter_Solve_ptr = _OpCache_Solve.find(param); + if(_OpCache_with_parameter_Solve_ptr == _OpCache_Solve.end()) { + copiedState.Solve(_tmp_1); + QueensWithEvents_4::_ProjectionWrite_Solve writeState = copiedState._update_for_Solve(); + std::unordered_map<QueensWithEvents_4::_ProjectionRead_Solve, QueensWithEvents_4::_ProjectionWrite_Solve, QueensWithEvents_4::_ProjectionRead_Solve::Hash, QueensWithEvents_4::_ProjectionRead_Solve::HashEqual> _OpCache_with_parameter_Solve; + _OpCache_with_parameter_Solve.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_Solve_lock(_ProjectionRead_Solve_mutex); + _OpCache_Solve.insert({param, _OpCache_with_parameter_Solve}); } - copiedState.stateAccessedVia = "Solve"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<BRelation<BInteger, BInteger >> _trid_1 = _trid_1_ptr->second; - for(const BRelation<BInteger, BInteger >& param : _trid_1) { - BRelation<BInteger, BInteger > _tmp_1 = param; - - QueensWithEvents_4 copiedState = state._copy(); - QueensWithEvents_4::_ProjectionRead_Solve readState = state._projected_state_for_Solve(); - - auto _OpCache_with_parameter_Solve_ptr = _OpCache_Solve.find(param); - if(_OpCache_with_parameter_Solve_ptr == _OpCache_Solve.end()) { + } else { + std::unordered_map<QueensWithEvents_4::_ProjectionRead_Solve, QueensWithEvents_4::_ProjectionWrite_Solve, QueensWithEvents_4::_ProjectionRead_Solve::Hash, QueensWithEvents_4::_ProjectionRead_Solve::HashEqual> _OpCache_with_parameter_Solve = _OpCache_with_parameter_Solve_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_Solve.find(readState); + if(writeState_ptr != _OpCache_with_parameter_Solve.end()) { + QueensWithEvents_4::_ProjectionWrite_Solve writeState = writeState_ptr->second; + copiedState._apply_update_for_Solve(writeState); + } else { copiedState.Solve(_tmp_1); QueensWithEvents_4::_ProjectionWrite_Solve writeState = copiedState._update_for_Solve(); - std::unordered_map<QueensWithEvents_4::_ProjectionRead_Solve, QueensWithEvents_4::_ProjectionWrite_Solve, QueensWithEvents_4::_ProjectionRead_Solve::Hash, QueensWithEvents_4::_ProjectionRead_Solve::HashEqual> _OpCache_with_parameter_Solve; - _OpCache_with_parameter_Solve.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_Solve_lock(_ProjectionRead_Solve_mutex); - _OpCache_Solve.insert({param, _OpCache_with_parameter_Solve}); - } - - } else { - std::unordered_map<QueensWithEvents_4::_ProjectionRead_Solve, QueensWithEvents_4::_ProjectionWrite_Solve, QueensWithEvents_4::_ProjectionRead_Solve::Hash, QueensWithEvents_4::_ProjectionRead_Solve::HashEqual> _OpCache_with_parameter_Solve = _OpCache_with_parameter_Solve_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_Solve.find(readState); - if(writeState_ptr != _OpCache_with_parameter_Solve.end()) { - QueensWithEvents_4::_ProjectionWrite_Solve writeState = writeState_ptr->second; - copiedState._apply_update_for_Solve(writeState); - } else { - copiedState.Solve(_tmp_1); - QueensWithEvents_4::_ProjectionWrite_Solve writeState = copiedState._update_for_Solve(); - { - std::unique_lock<std::mutex> _ProjectionRead_Solve_lock(_ProjectionRead_Solve_mutex); - _OpCache_with_parameter_Solve.insert({readState, writeState}); - } + _OpCache_with_parameter_Solve.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "Solve"; - result.insert(copiedState); + copiedState.stateAccessedVia = "Solve"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } @@ -707,7 +683,10 @@ class ModelChecker { copiedState.Solve(_tmp_1); copiedState.stateAccessedVia = "Solve"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } } diff --git a/benchmarks/model_checking_opreuse/C++/Train_1_beebook_deterministic_MC_POR_v3.cpp b/benchmarks/model_checking_opreuse/C++/Train_1_beebook_deterministic_MC_POR_v3.cpp index b7a2153c4f5b4f4e8dac30522994b044215cf896..0b5c4bc56063a61f009fe792636de63f89e6a263 100644 --- a/benchmarks/model_checking_opreuse/C++/Train_1_beebook_deterministic_MC_POR_v3.cpp +++ b/benchmarks/model_checking_opreuse/C++/Train_1_beebook_deterministic_MC_POR_v3.cpp @@ -10,7 +10,6 @@ #include <atomic> #include <any> #include <mutex> -#include <shared_mutex> #include <future> #include <boost/asio/post.hpp> #include <boost/asio/thread_pool.hpp> @@ -3402,12 +3401,16 @@ class ModelChecker { states.insert(machine); unvisitedStates.push_back(machine); - std::atomic<bool> stopThreads(false); + std::atomic<bool> stopThreads; + stopThreads = false; std::atomic<int> possibleQueueChanges; possibleQueueChanges = 0; - while(!unvisitedStates.empty() && !stopThreads.load()) { - possibleQueueChanges.fetch_add(1); + std::atomic<bool> waitFlag; + waitFlag = true; + + while(!unvisitedStates.empty() && !stopThreads) { + possibleQueueChanges += 1; Train_1_beebook_deterministic_MC_POR_v3 state = next(); std::packaged_task<void()> task([&, state] { std::unordered_set<Train_1_beebook_deterministic_MC_POR_v3, Train_1_beebook_deterministic_MC_POR_v3::Hash, Train_1_beebook_deterministic_MC_POR_v3::HashEqual> nextStates = generateNextStates(state); @@ -3428,12 +3431,14 @@ class ModelChecker { } } - possibleQueueChanges.fetch_sub(1); { std::unique_lock<std::mutex> lock(mutex); - if (!unvisitedStates.empty() || possibleQueueChanges.load() == 0) { + possibleQueueChanges -= 1; + int running = possibleQueueChanges; + if (!unvisitedStates.empty() || running == 0) { { std::unique_lock<std::mutex> lock(waitMutex); + waitFlag = false; waitCV.notify_one(); } } @@ -3443,24 +3448,27 @@ class ModelChecker { if(invariantViolated(state)) { invariantViolatedBool = true; counterExampleState = state; - stopThreads.store(true); + stopThreads = true; } if(nextStates.empty()) { deadlockDetected = true; counterExampleState = state; - stopThreads.store(true); + stopThreads = true; } }); + waitFlag = true; boost::asio::post(workers, std::move(task)); { std::unique_lock<std::mutex> lock(waitMutex); - waitCV.wait(lock, [&] { - return !unvisitedStates.empty() || possibleQueueChanges == 0; - }); + if(unvisitedStates.empty() && possibleQueueChanges > 0) { + waitCV.wait(lock, [&] { + return waitFlag == false; + }); + } } } workers.join(); @@ -3505,682 +3513,426 @@ class ModelChecker { std::unordered_set<Train_1_beebook_deterministic_MC_POR_v3, Train_1_beebook_deterministic_MC_POR_v3::Hash, Train_1_beebook_deterministic_MC_POR_v3::HashEqual> result = std::unordered_set<Train_1_beebook_deterministic_MC_POR_v3, Train_1_beebook_deterministic_MC_POR_v3::Hash, Train_1_beebook_deterministic_MC_POR_v3::HashEqual>(); if(isCaching) { Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead__tr_route_reservation read__tr_route_reservation_state = state._projected_state_for__tr_route_reservation(); + BSet<Train_1_beebook_deterministic_MC_POR_v3::ROUTES> _trid_1; auto _trid_1_ptr = _OpCache_tr_route_reservation.find(read__tr_route_reservation_state); if(_trid_1_ptr == _OpCache_tr_route_reservation.end()) { - BSet<Train_1_beebook_deterministic_MC_POR_v3::ROUTES> _trid_1 = state._tr_route_reservation(); + _trid_1 = state._tr_route_reservation(); { std::unique_lock<std::mutex> _ProjectionRead__tr_route_reservation_lock(_ProjectionRead__tr_route_reservation_mutex); _OpCache_tr_route_reservation.insert({read__tr_route_reservation_state, _trid_1}); } - for(const Train_1_beebook_deterministic_MC_POR_v3::ROUTES& param : _trid_1) { - Train_1_beebook_deterministic_MC_POR_v3::ROUTES _tmp_1 = param; - - Train_1_beebook_deterministic_MC_POR_v3 copiedState = state._copy(); - Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_reservation readState = state._projected_state_for_route_reservation(); + } else { + _trid_1 = _trid_1_ptr->second; + } - auto _OpCache_with_parameter_route_reservation_ptr = _OpCache_route_reservation.find(param); - if(_OpCache_with_parameter_route_reservation_ptr == _OpCache_route_reservation.end()) { - copiedState.route_reservation(_tmp_1); - Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_route_reservation writeState = copiedState._update_for_route_reservation(); - std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_reservation, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_route_reservation, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_reservation::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_reservation::HashEqual> _OpCache_with_parameter_route_reservation; - _OpCache_with_parameter_route_reservation.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_route_reservation_lock(_ProjectionRead_route_reservation_mutex); - _OpCache_route_reservation.insert({param, _OpCache_with_parameter_route_reservation}); - } + for(const Train_1_beebook_deterministic_MC_POR_v3::ROUTES& param : _trid_1) { + Train_1_beebook_deterministic_MC_POR_v3::ROUTES _tmp_1 = param; - } else { - std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_reservation, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_route_reservation, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_reservation::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_reservation::HashEqual> _OpCache_with_parameter_route_reservation = _OpCache_with_parameter_route_reservation_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_route_reservation.find(readState); - if(writeState_ptr != _OpCache_with_parameter_route_reservation.end()) { - Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_route_reservation writeState = writeState_ptr->second; - copiedState._apply_update_for_route_reservation(writeState); - } else { - copiedState.route_reservation(_tmp_1); - Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_route_reservation writeState = copiedState._update_for_route_reservation(); - { - std::unique_lock<std::mutex> _ProjectionRead_route_reservation_lock(_ProjectionRead_route_reservation_mutex); - _OpCache_with_parameter_route_reservation.insert({readState, writeState}); - } - } + Train_1_beebook_deterministic_MC_POR_v3 copiedState = state._copy(); + Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_reservation readState = state._projected_state_for_route_reservation(); + + auto _OpCache_with_parameter_route_reservation_ptr = _OpCache_route_reservation.find(param); + if(_OpCache_with_parameter_route_reservation_ptr == _OpCache_route_reservation.end()) { + copiedState.route_reservation(_tmp_1); + Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_route_reservation writeState = copiedState._update_for_route_reservation(); + std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_reservation, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_route_reservation, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_reservation::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_reservation::HashEqual> _OpCache_with_parameter_route_reservation; + _OpCache_with_parameter_route_reservation.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_route_reservation_lock(_ProjectionRead_route_reservation_mutex); + _OpCache_route_reservation.insert({param, _OpCache_with_parameter_route_reservation}); } - copiedState.stateAccessedVia = "route_reservation"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<Train_1_beebook_deterministic_MC_POR_v3::ROUTES> _trid_1 = _trid_1_ptr->second; - for(const Train_1_beebook_deterministic_MC_POR_v3::ROUTES& param : _trid_1) { - Train_1_beebook_deterministic_MC_POR_v3::ROUTES _tmp_1 = param; - - Train_1_beebook_deterministic_MC_POR_v3 copiedState = state._copy(); - Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_reservation readState = state._projected_state_for_route_reservation(); - - auto _OpCache_with_parameter_route_reservation_ptr = _OpCache_route_reservation.find(param); - if(_OpCache_with_parameter_route_reservation_ptr == _OpCache_route_reservation.end()) { + } else { + std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_reservation, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_route_reservation, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_reservation::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_reservation::HashEqual> _OpCache_with_parameter_route_reservation = _OpCache_with_parameter_route_reservation_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_route_reservation.find(readState); + if(writeState_ptr != _OpCache_with_parameter_route_reservation.end()) { + Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_route_reservation writeState = writeState_ptr->second; + copiedState._apply_update_for_route_reservation(writeState); + } else { copiedState.route_reservation(_tmp_1); Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_route_reservation writeState = copiedState._update_for_route_reservation(); - std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_reservation, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_route_reservation, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_reservation::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_reservation::HashEqual> _OpCache_with_parameter_route_reservation; - _OpCache_with_parameter_route_reservation.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_route_reservation_lock(_ProjectionRead_route_reservation_mutex); - _OpCache_route_reservation.insert({param, _OpCache_with_parameter_route_reservation}); - } - - } else { - std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_reservation, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_route_reservation, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_reservation::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_reservation::HashEqual> _OpCache_with_parameter_route_reservation = _OpCache_with_parameter_route_reservation_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_route_reservation.find(readState); - if(writeState_ptr != _OpCache_with_parameter_route_reservation.end()) { - Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_route_reservation writeState = writeState_ptr->second; - copiedState._apply_update_for_route_reservation(writeState); - } else { - copiedState.route_reservation(_tmp_1); - Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_route_reservation writeState = copiedState._update_for_route_reservation(); - { - std::unique_lock<std::mutex> _ProjectionRead_route_reservation_lock(_ProjectionRead_route_reservation_mutex); - _OpCache_with_parameter_route_reservation.insert({readState, writeState}); - } + _OpCache_with_parameter_route_reservation.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "route_reservation"; - result.insert(copiedState); + copiedState.stateAccessedVia = "route_reservation"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead__tr_route_freeing read__tr_route_freeing_state = state._projected_state_for__tr_route_freeing(); + BSet<Train_1_beebook_deterministic_MC_POR_v3::ROUTES> _trid_2; auto _trid_2_ptr = _OpCache_tr_route_freeing.find(read__tr_route_freeing_state); if(_trid_2_ptr == _OpCache_tr_route_freeing.end()) { - BSet<Train_1_beebook_deterministic_MC_POR_v3::ROUTES> _trid_2 = state._tr_route_freeing(); + _trid_2 = state._tr_route_freeing(); { std::unique_lock<std::mutex> _ProjectionRead__tr_route_freeing_lock(_ProjectionRead__tr_route_freeing_mutex); _OpCache_tr_route_freeing.insert({read__tr_route_freeing_state, _trid_2}); } - for(const Train_1_beebook_deterministic_MC_POR_v3::ROUTES& param : _trid_2) { - Train_1_beebook_deterministic_MC_POR_v3::ROUTES _tmp_1 = param; - - Train_1_beebook_deterministic_MC_POR_v3 copiedState = state._copy(); - Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_freeing readState = state._projected_state_for_route_freeing(); + } else { + _trid_2 = _trid_2_ptr->second; + } - auto _OpCache_with_parameter_route_freeing_ptr = _OpCache_route_freeing.find(param); - if(_OpCache_with_parameter_route_freeing_ptr == _OpCache_route_freeing.end()) { - copiedState.route_freeing(_tmp_1); - Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_route_freeing writeState = copiedState._update_for_route_freeing(); - std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_freeing, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_route_freeing, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_freeing::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_freeing::HashEqual> _OpCache_with_parameter_route_freeing; - _OpCache_with_parameter_route_freeing.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_route_freeing_lock(_ProjectionRead_route_freeing_mutex); - _OpCache_route_freeing.insert({param, _OpCache_with_parameter_route_freeing}); - } + for(const Train_1_beebook_deterministic_MC_POR_v3::ROUTES& param : _trid_2) { + Train_1_beebook_deterministic_MC_POR_v3::ROUTES _tmp_1 = param; - } else { - std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_freeing, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_route_freeing, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_freeing::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_freeing::HashEqual> _OpCache_with_parameter_route_freeing = _OpCache_with_parameter_route_freeing_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_route_freeing.find(readState); - if(writeState_ptr != _OpCache_with_parameter_route_freeing.end()) { - Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_route_freeing writeState = writeState_ptr->second; - copiedState._apply_update_for_route_freeing(writeState); - } else { - copiedState.route_freeing(_tmp_1); - Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_route_freeing writeState = copiedState._update_for_route_freeing(); - { - std::unique_lock<std::mutex> _ProjectionRead_route_freeing_lock(_ProjectionRead_route_freeing_mutex); - _OpCache_with_parameter_route_freeing.insert({readState, writeState}); - } - } + Train_1_beebook_deterministic_MC_POR_v3 copiedState = state._copy(); + Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_freeing readState = state._projected_state_for_route_freeing(); + + auto _OpCache_with_parameter_route_freeing_ptr = _OpCache_route_freeing.find(param); + if(_OpCache_with_parameter_route_freeing_ptr == _OpCache_route_freeing.end()) { + copiedState.route_freeing(_tmp_1); + Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_route_freeing writeState = copiedState._update_for_route_freeing(); + std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_freeing, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_route_freeing, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_freeing::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_freeing::HashEqual> _OpCache_with_parameter_route_freeing; + _OpCache_with_parameter_route_freeing.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_route_freeing_lock(_ProjectionRead_route_freeing_mutex); + _OpCache_route_freeing.insert({param, _OpCache_with_parameter_route_freeing}); } - copiedState.stateAccessedVia = "route_freeing"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<Train_1_beebook_deterministic_MC_POR_v3::ROUTES> _trid_2 = _trid_2_ptr->second; - for(const Train_1_beebook_deterministic_MC_POR_v3::ROUTES& param : _trid_2) { - Train_1_beebook_deterministic_MC_POR_v3::ROUTES _tmp_1 = param; - - Train_1_beebook_deterministic_MC_POR_v3 copiedState = state._copy(); - Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_freeing readState = state._projected_state_for_route_freeing(); - - auto _OpCache_with_parameter_route_freeing_ptr = _OpCache_route_freeing.find(param); - if(_OpCache_with_parameter_route_freeing_ptr == _OpCache_route_freeing.end()) { + } else { + std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_freeing, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_route_freeing, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_freeing::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_freeing::HashEqual> _OpCache_with_parameter_route_freeing = _OpCache_with_parameter_route_freeing_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_route_freeing.find(readState); + if(writeState_ptr != _OpCache_with_parameter_route_freeing.end()) { + Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_route_freeing writeState = writeState_ptr->second; + copiedState._apply_update_for_route_freeing(writeState); + } else { copiedState.route_freeing(_tmp_1); Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_route_freeing writeState = copiedState._update_for_route_freeing(); - std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_freeing, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_route_freeing, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_freeing::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_freeing::HashEqual> _OpCache_with_parameter_route_freeing; - _OpCache_with_parameter_route_freeing.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_route_freeing_lock(_ProjectionRead_route_freeing_mutex); - _OpCache_route_freeing.insert({param, _OpCache_with_parameter_route_freeing}); - } - - } else { - std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_freeing, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_route_freeing, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_freeing::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_freeing::HashEqual> _OpCache_with_parameter_route_freeing = _OpCache_with_parameter_route_freeing_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_route_freeing.find(readState); - if(writeState_ptr != _OpCache_with_parameter_route_freeing.end()) { - Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_route_freeing writeState = writeState_ptr->second; - copiedState._apply_update_for_route_freeing(writeState); - } else { - copiedState.route_freeing(_tmp_1); - Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_route_freeing writeState = copiedState._update_for_route_freeing(); - { - std::unique_lock<std::mutex> _ProjectionRead_route_freeing_lock(_ProjectionRead_route_freeing_mutex); - _OpCache_with_parameter_route_freeing.insert({readState, writeState}); - } + _OpCache_with_parameter_route_freeing.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "route_freeing"; - result.insert(copiedState); + copiedState.stateAccessedVia = "route_freeing"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead__tr_FRONT_MOVE_1 read__tr_FRONT_MOVE_1_state = state._projected_state_for__tr_FRONT_MOVE_1(); + BSet<Train_1_beebook_deterministic_MC_POR_v3::ROUTES> _trid_3; auto _trid_3_ptr = _OpCache_tr_FRONT_MOVE_1.find(read__tr_FRONT_MOVE_1_state); if(_trid_3_ptr == _OpCache_tr_FRONT_MOVE_1.end()) { - BSet<Train_1_beebook_deterministic_MC_POR_v3::ROUTES> _trid_3 = state._tr_FRONT_MOVE_1(); + _trid_3 = state._tr_FRONT_MOVE_1(); { std::unique_lock<std::mutex> _ProjectionRead__tr_FRONT_MOVE_1_lock(_ProjectionRead__tr_FRONT_MOVE_1_mutex); _OpCache_tr_FRONT_MOVE_1.insert({read__tr_FRONT_MOVE_1_state, _trid_3}); } - for(const Train_1_beebook_deterministic_MC_POR_v3::ROUTES& param : _trid_3) { - Train_1_beebook_deterministic_MC_POR_v3::ROUTES _tmp_1 = param; - - Train_1_beebook_deterministic_MC_POR_v3 copiedState = state._copy(); - Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_FRONT_MOVE_1 readState = state._projected_state_for_FRONT_MOVE_1(); + } else { + _trid_3 = _trid_3_ptr->second; + } - auto _OpCache_with_parameter_FRONT_MOVE_1_ptr = _OpCache_FRONT_MOVE_1.find(param); - if(_OpCache_with_parameter_FRONT_MOVE_1_ptr == _OpCache_FRONT_MOVE_1.end()) { - copiedState.FRONT_MOVE_1(_tmp_1); - Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_FRONT_MOVE_1 writeState = copiedState._update_for_FRONT_MOVE_1(); - std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_FRONT_MOVE_1, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_FRONT_MOVE_1, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_FRONT_MOVE_1::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_FRONT_MOVE_1::HashEqual> _OpCache_with_parameter_FRONT_MOVE_1; - _OpCache_with_parameter_FRONT_MOVE_1.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_FRONT_MOVE_1_lock(_ProjectionRead_FRONT_MOVE_1_mutex); - _OpCache_FRONT_MOVE_1.insert({param, _OpCache_with_parameter_FRONT_MOVE_1}); - } + for(const Train_1_beebook_deterministic_MC_POR_v3::ROUTES& param : _trid_3) { + Train_1_beebook_deterministic_MC_POR_v3::ROUTES _tmp_1 = param; - } else { - std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_FRONT_MOVE_1, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_FRONT_MOVE_1, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_FRONT_MOVE_1::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_FRONT_MOVE_1::HashEqual> _OpCache_with_parameter_FRONT_MOVE_1 = _OpCache_with_parameter_FRONT_MOVE_1_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_FRONT_MOVE_1.find(readState); - if(writeState_ptr != _OpCache_with_parameter_FRONT_MOVE_1.end()) { - Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_FRONT_MOVE_1 writeState = writeState_ptr->second; - copiedState._apply_update_for_FRONT_MOVE_1(writeState); - } else { - copiedState.FRONT_MOVE_1(_tmp_1); - Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_FRONT_MOVE_1 writeState = copiedState._update_for_FRONT_MOVE_1(); - { - std::unique_lock<std::mutex> _ProjectionRead_FRONT_MOVE_1_lock(_ProjectionRead_FRONT_MOVE_1_mutex); - _OpCache_with_parameter_FRONT_MOVE_1.insert({readState, writeState}); - } - } + Train_1_beebook_deterministic_MC_POR_v3 copiedState = state._copy(); + Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_FRONT_MOVE_1 readState = state._projected_state_for_FRONT_MOVE_1(); + + auto _OpCache_with_parameter_FRONT_MOVE_1_ptr = _OpCache_FRONT_MOVE_1.find(param); + if(_OpCache_with_parameter_FRONT_MOVE_1_ptr == _OpCache_FRONT_MOVE_1.end()) { + copiedState.FRONT_MOVE_1(_tmp_1); + Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_FRONT_MOVE_1 writeState = copiedState._update_for_FRONT_MOVE_1(); + std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_FRONT_MOVE_1, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_FRONT_MOVE_1, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_FRONT_MOVE_1::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_FRONT_MOVE_1::HashEqual> _OpCache_with_parameter_FRONT_MOVE_1; + _OpCache_with_parameter_FRONT_MOVE_1.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_FRONT_MOVE_1_lock(_ProjectionRead_FRONT_MOVE_1_mutex); + _OpCache_FRONT_MOVE_1.insert({param, _OpCache_with_parameter_FRONT_MOVE_1}); } - copiedState.stateAccessedVia = "FRONT_MOVE_1"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<Train_1_beebook_deterministic_MC_POR_v3::ROUTES> _trid_3 = _trid_3_ptr->second; - for(const Train_1_beebook_deterministic_MC_POR_v3::ROUTES& param : _trid_3) { - Train_1_beebook_deterministic_MC_POR_v3::ROUTES _tmp_1 = param; - - Train_1_beebook_deterministic_MC_POR_v3 copiedState = state._copy(); - Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_FRONT_MOVE_1 readState = state._projected_state_for_FRONT_MOVE_1(); - - auto _OpCache_with_parameter_FRONT_MOVE_1_ptr = _OpCache_FRONT_MOVE_1.find(param); - if(_OpCache_with_parameter_FRONT_MOVE_1_ptr == _OpCache_FRONT_MOVE_1.end()) { + } else { + std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_FRONT_MOVE_1, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_FRONT_MOVE_1, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_FRONT_MOVE_1::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_FRONT_MOVE_1::HashEqual> _OpCache_with_parameter_FRONT_MOVE_1 = _OpCache_with_parameter_FRONT_MOVE_1_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_FRONT_MOVE_1.find(readState); + if(writeState_ptr != _OpCache_with_parameter_FRONT_MOVE_1.end()) { + Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_FRONT_MOVE_1 writeState = writeState_ptr->second; + copiedState._apply_update_for_FRONT_MOVE_1(writeState); + } else { copiedState.FRONT_MOVE_1(_tmp_1); Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_FRONT_MOVE_1 writeState = copiedState._update_for_FRONT_MOVE_1(); - std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_FRONT_MOVE_1, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_FRONT_MOVE_1, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_FRONT_MOVE_1::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_FRONT_MOVE_1::HashEqual> _OpCache_with_parameter_FRONT_MOVE_1; - _OpCache_with_parameter_FRONT_MOVE_1.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_FRONT_MOVE_1_lock(_ProjectionRead_FRONT_MOVE_1_mutex); - _OpCache_FRONT_MOVE_1.insert({param, _OpCache_with_parameter_FRONT_MOVE_1}); - } - - } else { - std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_FRONT_MOVE_1, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_FRONT_MOVE_1, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_FRONT_MOVE_1::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_FRONT_MOVE_1::HashEqual> _OpCache_with_parameter_FRONT_MOVE_1 = _OpCache_with_parameter_FRONT_MOVE_1_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_FRONT_MOVE_1.find(readState); - if(writeState_ptr != _OpCache_with_parameter_FRONT_MOVE_1.end()) { - Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_FRONT_MOVE_1 writeState = writeState_ptr->second; - copiedState._apply_update_for_FRONT_MOVE_1(writeState); - } else { - copiedState.FRONT_MOVE_1(_tmp_1); - Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_FRONT_MOVE_1 writeState = copiedState._update_for_FRONT_MOVE_1(); - { - std::unique_lock<std::mutex> _ProjectionRead_FRONT_MOVE_1_lock(_ProjectionRead_FRONT_MOVE_1_mutex); - _OpCache_with_parameter_FRONT_MOVE_1.insert({readState, writeState}); - } + _OpCache_with_parameter_FRONT_MOVE_1.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "FRONT_MOVE_1"; - result.insert(copiedState); + copiedState.stateAccessedVia = "FRONT_MOVE_1"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead__tr_FRONT_MOVE_2 read__tr_FRONT_MOVE_2_state = state._projected_state_for__tr_FRONT_MOVE_2(); + BSet<Train_1_beebook_deterministic_MC_POR_v3::BLOCKS> _trid_4; auto _trid_4_ptr = _OpCache_tr_FRONT_MOVE_2.find(read__tr_FRONT_MOVE_2_state); if(_trid_4_ptr == _OpCache_tr_FRONT_MOVE_2.end()) { - BSet<Train_1_beebook_deterministic_MC_POR_v3::BLOCKS> _trid_4 = state._tr_FRONT_MOVE_2(); + _trid_4 = state._tr_FRONT_MOVE_2(); { std::unique_lock<std::mutex> _ProjectionRead__tr_FRONT_MOVE_2_lock(_ProjectionRead__tr_FRONT_MOVE_2_mutex); _OpCache_tr_FRONT_MOVE_2.insert({read__tr_FRONT_MOVE_2_state, _trid_4}); } - for(const Train_1_beebook_deterministic_MC_POR_v3::BLOCKS& param : _trid_4) { - Train_1_beebook_deterministic_MC_POR_v3::BLOCKS _tmp_1 = param; - - Train_1_beebook_deterministic_MC_POR_v3 copiedState = state._copy(); - Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_FRONT_MOVE_2 readState = state._projected_state_for_FRONT_MOVE_2(); + } else { + _trid_4 = _trid_4_ptr->second; + } - auto _OpCache_with_parameter_FRONT_MOVE_2_ptr = _OpCache_FRONT_MOVE_2.find(param); - if(_OpCache_with_parameter_FRONT_MOVE_2_ptr == _OpCache_FRONT_MOVE_2.end()) { - copiedState.FRONT_MOVE_2(_tmp_1); - Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_FRONT_MOVE_2 writeState = copiedState._update_for_FRONT_MOVE_2(); - std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_FRONT_MOVE_2, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_FRONT_MOVE_2, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_FRONT_MOVE_2::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_FRONT_MOVE_2::HashEqual> _OpCache_with_parameter_FRONT_MOVE_2; - _OpCache_with_parameter_FRONT_MOVE_2.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_FRONT_MOVE_2_lock(_ProjectionRead_FRONT_MOVE_2_mutex); - _OpCache_FRONT_MOVE_2.insert({param, _OpCache_with_parameter_FRONT_MOVE_2}); - } + for(const Train_1_beebook_deterministic_MC_POR_v3::BLOCKS& param : _trid_4) { + Train_1_beebook_deterministic_MC_POR_v3::BLOCKS _tmp_1 = param; - } else { - std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_FRONT_MOVE_2, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_FRONT_MOVE_2, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_FRONT_MOVE_2::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_FRONT_MOVE_2::HashEqual> _OpCache_with_parameter_FRONT_MOVE_2 = _OpCache_with_parameter_FRONT_MOVE_2_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_FRONT_MOVE_2.find(readState); - if(writeState_ptr != _OpCache_with_parameter_FRONT_MOVE_2.end()) { - Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_FRONT_MOVE_2 writeState = writeState_ptr->second; - copiedState._apply_update_for_FRONT_MOVE_2(writeState); - } else { - copiedState.FRONT_MOVE_2(_tmp_1); - Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_FRONT_MOVE_2 writeState = copiedState._update_for_FRONT_MOVE_2(); - { - std::unique_lock<std::mutex> _ProjectionRead_FRONT_MOVE_2_lock(_ProjectionRead_FRONT_MOVE_2_mutex); - _OpCache_with_parameter_FRONT_MOVE_2.insert({readState, writeState}); - } - } + Train_1_beebook_deterministic_MC_POR_v3 copiedState = state._copy(); + Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_FRONT_MOVE_2 readState = state._projected_state_for_FRONT_MOVE_2(); + + auto _OpCache_with_parameter_FRONT_MOVE_2_ptr = _OpCache_FRONT_MOVE_2.find(param); + if(_OpCache_with_parameter_FRONT_MOVE_2_ptr == _OpCache_FRONT_MOVE_2.end()) { + copiedState.FRONT_MOVE_2(_tmp_1); + Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_FRONT_MOVE_2 writeState = copiedState._update_for_FRONT_MOVE_2(); + std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_FRONT_MOVE_2, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_FRONT_MOVE_2, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_FRONT_MOVE_2::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_FRONT_MOVE_2::HashEqual> _OpCache_with_parameter_FRONT_MOVE_2; + _OpCache_with_parameter_FRONT_MOVE_2.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_FRONT_MOVE_2_lock(_ProjectionRead_FRONT_MOVE_2_mutex); + _OpCache_FRONT_MOVE_2.insert({param, _OpCache_with_parameter_FRONT_MOVE_2}); } - copiedState.stateAccessedVia = "FRONT_MOVE_2"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<Train_1_beebook_deterministic_MC_POR_v3::BLOCKS> _trid_4 = _trid_4_ptr->second; - for(const Train_1_beebook_deterministic_MC_POR_v3::BLOCKS& param : _trid_4) { - Train_1_beebook_deterministic_MC_POR_v3::BLOCKS _tmp_1 = param; - - Train_1_beebook_deterministic_MC_POR_v3 copiedState = state._copy(); - Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_FRONT_MOVE_2 readState = state._projected_state_for_FRONT_MOVE_2(); - - auto _OpCache_with_parameter_FRONT_MOVE_2_ptr = _OpCache_FRONT_MOVE_2.find(param); - if(_OpCache_with_parameter_FRONT_MOVE_2_ptr == _OpCache_FRONT_MOVE_2.end()) { + } else { + std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_FRONT_MOVE_2, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_FRONT_MOVE_2, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_FRONT_MOVE_2::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_FRONT_MOVE_2::HashEqual> _OpCache_with_parameter_FRONT_MOVE_2 = _OpCache_with_parameter_FRONT_MOVE_2_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_FRONT_MOVE_2.find(readState); + if(writeState_ptr != _OpCache_with_parameter_FRONT_MOVE_2.end()) { + Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_FRONT_MOVE_2 writeState = writeState_ptr->second; + copiedState._apply_update_for_FRONT_MOVE_2(writeState); + } else { copiedState.FRONT_MOVE_2(_tmp_1); Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_FRONT_MOVE_2 writeState = copiedState._update_for_FRONT_MOVE_2(); - std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_FRONT_MOVE_2, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_FRONT_MOVE_2, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_FRONT_MOVE_2::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_FRONT_MOVE_2::HashEqual> _OpCache_with_parameter_FRONT_MOVE_2; - _OpCache_with_parameter_FRONT_MOVE_2.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_FRONT_MOVE_2_lock(_ProjectionRead_FRONT_MOVE_2_mutex); - _OpCache_FRONT_MOVE_2.insert({param, _OpCache_with_parameter_FRONT_MOVE_2}); - } - - } else { - std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_FRONT_MOVE_2, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_FRONT_MOVE_2, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_FRONT_MOVE_2::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_FRONT_MOVE_2::HashEqual> _OpCache_with_parameter_FRONT_MOVE_2 = _OpCache_with_parameter_FRONT_MOVE_2_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_FRONT_MOVE_2.find(readState); - if(writeState_ptr != _OpCache_with_parameter_FRONT_MOVE_2.end()) { - Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_FRONT_MOVE_2 writeState = writeState_ptr->second; - copiedState._apply_update_for_FRONT_MOVE_2(writeState); - } else { - copiedState.FRONT_MOVE_2(_tmp_1); - Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_FRONT_MOVE_2 writeState = copiedState._update_for_FRONT_MOVE_2(); - { - std::unique_lock<std::mutex> _ProjectionRead_FRONT_MOVE_2_lock(_ProjectionRead_FRONT_MOVE_2_mutex); - _OpCache_with_parameter_FRONT_MOVE_2.insert({readState, writeState}); - } + _OpCache_with_parameter_FRONT_MOVE_2.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "FRONT_MOVE_2"; - result.insert(copiedState); + copiedState.stateAccessedVia = "FRONT_MOVE_2"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead__tr_BACK_MOVE_1 read__tr_BACK_MOVE_1_state = state._projected_state_for__tr_BACK_MOVE_1(); + BSet<Train_1_beebook_deterministic_MC_POR_v3::BLOCKS> _trid_5; auto _trid_5_ptr = _OpCache_tr_BACK_MOVE_1.find(read__tr_BACK_MOVE_1_state); if(_trid_5_ptr == _OpCache_tr_BACK_MOVE_1.end()) { - BSet<Train_1_beebook_deterministic_MC_POR_v3::BLOCKS> _trid_5 = state._tr_BACK_MOVE_1(); + _trid_5 = state._tr_BACK_MOVE_1(); { std::unique_lock<std::mutex> _ProjectionRead__tr_BACK_MOVE_1_lock(_ProjectionRead__tr_BACK_MOVE_1_mutex); _OpCache_tr_BACK_MOVE_1.insert({read__tr_BACK_MOVE_1_state, _trid_5}); } - for(const Train_1_beebook_deterministic_MC_POR_v3::BLOCKS& param : _trid_5) { - Train_1_beebook_deterministic_MC_POR_v3::BLOCKS _tmp_1 = param; - - Train_1_beebook_deterministic_MC_POR_v3 copiedState = state._copy(); - Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_BACK_MOVE_1 readState = state._projected_state_for_BACK_MOVE_1(); + } else { + _trid_5 = _trid_5_ptr->second; + } - auto _OpCache_with_parameter_BACK_MOVE_1_ptr = _OpCache_BACK_MOVE_1.find(param); - if(_OpCache_with_parameter_BACK_MOVE_1_ptr == _OpCache_BACK_MOVE_1.end()) { - copiedState.BACK_MOVE_1(_tmp_1); - Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_BACK_MOVE_1 writeState = copiedState._update_for_BACK_MOVE_1(); - std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_BACK_MOVE_1, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_BACK_MOVE_1, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_BACK_MOVE_1::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_BACK_MOVE_1::HashEqual> _OpCache_with_parameter_BACK_MOVE_1; - _OpCache_with_parameter_BACK_MOVE_1.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_BACK_MOVE_1_lock(_ProjectionRead_BACK_MOVE_1_mutex); - _OpCache_BACK_MOVE_1.insert({param, _OpCache_with_parameter_BACK_MOVE_1}); - } + for(const Train_1_beebook_deterministic_MC_POR_v3::BLOCKS& param : _trid_5) { + Train_1_beebook_deterministic_MC_POR_v3::BLOCKS _tmp_1 = param; - } else { - std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_BACK_MOVE_1, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_BACK_MOVE_1, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_BACK_MOVE_1::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_BACK_MOVE_1::HashEqual> _OpCache_with_parameter_BACK_MOVE_1 = _OpCache_with_parameter_BACK_MOVE_1_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_BACK_MOVE_1.find(readState); - if(writeState_ptr != _OpCache_with_parameter_BACK_MOVE_1.end()) { - Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_BACK_MOVE_1 writeState = writeState_ptr->second; - copiedState._apply_update_for_BACK_MOVE_1(writeState); - } else { - copiedState.BACK_MOVE_1(_tmp_1); - Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_BACK_MOVE_1 writeState = copiedState._update_for_BACK_MOVE_1(); - { - std::unique_lock<std::mutex> _ProjectionRead_BACK_MOVE_1_lock(_ProjectionRead_BACK_MOVE_1_mutex); - _OpCache_with_parameter_BACK_MOVE_1.insert({readState, writeState}); - } - } + Train_1_beebook_deterministic_MC_POR_v3 copiedState = state._copy(); + Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_BACK_MOVE_1 readState = state._projected_state_for_BACK_MOVE_1(); + + auto _OpCache_with_parameter_BACK_MOVE_1_ptr = _OpCache_BACK_MOVE_1.find(param); + if(_OpCache_with_parameter_BACK_MOVE_1_ptr == _OpCache_BACK_MOVE_1.end()) { + copiedState.BACK_MOVE_1(_tmp_1); + Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_BACK_MOVE_1 writeState = copiedState._update_for_BACK_MOVE_1(); + std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_BACK_MOVE_1, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_BACK_MOVE_1, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_BACK_MOVE_1::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_BACK_MOVE_1::HashEqual> _OpCache_with_parameter_BACK_MOVE_1; + _OpCache_with_parameter_BACK_MOVE_1.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_BACK_MOVE_1_lock(_ProjectionRead_BACK_MOVE_1_mutex); + _OpCache_BACK_MOVE_1.insert({param, _OpCache_with_parameter_BACK_MOVE_1}); } - copiedState.stateAccessedVia = "BACK_MOVE_1"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<Train_1_beebook_deterministic_MC_POR_v3::BLOCKS> _trid_5 = _trid_5_ptr->second; - for(const Train_1_beebook_deterministic_MC_POR_v3::BLOCKS& param : _trid_5) { - Train_1_beebook_deterministic_MC_POR_v3::BLOCKS _tmp_1 = param; - - Train_1_beebook_deterministic_MC_POR_v3 copiedState = state._copy(); - Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_BACK_MOVE_1 readState = state._projected_state_for_BACK_MOVE_1(); - - auto _OpCache_with_parameter_BACK_MOVE_1_ptr = _OpCache_BACK_MOVE_1.find(param); - if(_OpCache_with_parameter_BACK_MOVE_1_ptr == _OpCache_BACK_MOVE_1.end()) { + } else { + std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_BACK_MOVE_1, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_BACK_MOVE_1, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_BACK_MOVE_1::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_BACK_MOVE_1::HashEqual> _OpCache_with_parameter_BACK_MOVE_1 = _OpCache_with_parameter_BACK_MOVE_1_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_BACK_MOVE_1.find(readState); + if(writeState_ptr != _OpCache_with_parameter_BACK_MOVE_1.end()) { + Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_BACK_MOVE_1 writeState = writeState_ptr->second; + copiedState._apply_update_for_BACK_MOVE_1(writeState); + } else { copiedState.BACK_MOVE_1(_tmp_1); Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_BACK_MOVE_1 writeState = copiedState._update_for_BACK_MOVE_1(); - std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_BACK_MOVE_1, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_BACK_MOVE_1, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_BACK_MOVE_1::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_BACK_MOVE_1::HashEqual> _OpCache_with_parameter_BACK_MOVE_1; - _OpCache_with_parameter_BACK_MOVE_1.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_BACK_MOVE_1_lock(_ProjectionRead_BACK_MOVE_1_mutex); - _OpCache_BACK_MOVE_1.insert({param, _OpCache_with_parameter_BACK_MOVE_1}); - } - - } else { - std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_BACK_MOVE_1, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_BACK_MOVE_1, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_BACK_MOVE_1::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_BACK_MOVE_1::HashEqual> _OpCache_with_parameter_BACK_MOVE_1 = _OpCache_with_parameter_BACK_MOVE_1_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_BACK_MOVE_1.find(readState); - if(writeState_ptr != _OpCache_with_parameter_BACK_MOVE_1.end()) { - Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_BACK_MOVE_1 writeState = writeState_ptr->second; - copiedState._apply_update_for_BACK_MOVE_1(writeState); - } else { - copiedState.BACK_MOVE_1(_tmp_1); - Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_BACK_MOVE_1 writeState = copiedState._update_for_BACK_MOVE_1(); - { - std::unique_lock<std::mutex> _ProjectionRead_BACK_MOVE_1_lock(_ProjectionRead_BACK_MOVE_1_mutex); - _OpCache_with_parameter_BACK_MOVE_1.insert({readState, writeState}); - } + _OpCache_with_parameter_BACK_MOVE_1.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "BACK_MOVE_1"; - result.insert(copiedState); + copiedState.stateAccessedVia = "BACK_MOVE_1"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead__tr_BACK_MOVE_2 read__tr_BACK_MOVE_2_state = state._projected_state_for__tr_BACK_MOVE_2(); + BSet<Train_1_beebook_deterministic_MC_POR_v3::BLOCKS> _trid_6; auto _trid_6_ptr = _OpCache_tr_BACK_MOVE_2.find(read__tr_BACK_MOVE_2_state); if(_trid_6_ptr == _OpCache_tr_BACK_MOVE_2.end()) { - BSet<Train_1_beebook_deterministic_MC_POR_v3::BLOCKS> _trid_6 = state._tr_BACK_MOVE_2(); + _trid_6 = state._tr_BACK_MOVE_2(); { std::unique_lock<std::mutex> _ProjectionRead__tr_BACK_MOVE_2_lock(_ProjectionRead__tr_BACK_MOVE_2_mutex); _OpCache_tr_BACK_MOVE_2.insert({read__tr_BACK_MOVE_2_state, _trid_6}); } - for(const Train_1_beebook_deterministic_MC_POR_v3::BLOCKS& param : _trid_6) { - Train_1_beebook_deterministic_MC_POR_v3::BLOCKS _tmp_1 = param; - - Train_1_beebook_deterministic_MC_POR_v3 copiedState = state._copy(); - Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_BACK_MOVE_2 readState = state._projected_state_for_BACK_MOVE_2(); + } else { + _trid_6 = _trid_6_ptr->second; + } - auto _OpCache_with_parameter_BACK_MOVE_2_ptr = _OpCache_BACK_MOVE_2.find(param); - if(_OpCache_with_parameter_BACK_MOVE_2_ptr == _OpCache_BACK_MOVE_2.end()) { - copiedState.BACK_MOVE_2(_tmp_1); - Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_BACK_MOVE_2 writeState = copiedState._update_for_BACK_MOVE_2(); - std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_BACK_MOVE_2, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_BACK_MOVE_2, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_BACK_MOVE_2::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_BACK_MOVE_2::HashEqual> _OpCache_with_parameter_BACK_MOVE_2; - _OpCache_with_parameter_BACK_MOVE_2.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_BACK_MOVE_2_lock(_ProjectionRead_BACK_MOVE_2_mutex); - _OpCache_BACK_MOVE_2.insert({param, _OpCache_with_parameter_BACK_MOVE_2}); - } + for(const Train_1_beebook_deterministic_MC_POR_v3::BLOCKS& param : _trid_6) { + Train_1_beebook_deterministic_MC_POR_v3::BLOCKS _tmp_1 = param; - } else { - std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_BACK_MOVE_2, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_BACK_MOVE_2, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_BACK_MOVE_2::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_BACK_MOVE_2::HashEqual> _OpCache_with_parameter_BACK_MOVE_2 = _OpCache_with_parameter_BACK_MOVE_2_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_BACK_MOVE_2.find(readState); - if(writeState_ptr != _OpCache_with_parameter_BACK_MOVE_2.end()) { - Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_BACK_MOVE_2 writeState = writeState_ptr->second; - copiedState._apply_update_for_BACK_MOVE_2(writeState); - } else { - copiedState.BACK_MOVE_2(_tmp_1); - Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_BACK_MOVE_2 writeState = copiedState._update_for_BACK_MOVE_2(); - { - std::unique_lock<std::mutex> _ProjectionRead_BACK_MOVE_2_lock(_ProjectionRead_BACK_MOVE_2_mutex); - _OpCache_with_parameter_BACK_MOVE_2.insert({readState, writeState}); - } - } + Train_1_beebook_deterministic_MC_POR_v3 copiedState = state._copy(); + Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_BACK_MOVE_2 readState = state._projected_state_for_BACK_MOVE_2(); + + auto _OpCache_with_parameter_BACK_MOVE_2_ptr = _OpCache_BACK_MOVE_2.find(param); + if(_OpCache_with_parameter_BACK_MOVE_2_ptr == _OpCache_BACK_MOVE_2.end()) { + copiedState.BACK_MOVE_2(_tmp_1); + Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_BACK_MOVE_2 writeState = copiedState._update_for_BACK_MOVE_2(); + std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_BACK_MOVE_2, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_BACK_MOVE_2, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_BACK_MOVE_2::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_BACK_MOVE_2::HashEqual> _OpCache_with_parameter_BACK_MOVE_2; + _OpCache_with_parameter_BACK_MOVE_2.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_BACK_MOVE_2_lock(_ProjectionRead_BACK_MOVE_2_mutex); + _OpCache_BACK_MOVE_2.insert({param, _OpCache_with_parameter_BACK_MOVE_2}); } - copiedState.stateAccessedVia = "BACK_MOVE_2"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<Train_1_beebook_deterministic_MC_POR_v3::BLOCKS> _trid_6 = _trid_6_ptr->second; - for(const Train_1_beebook_deterministic_MC_POR_v3::BLOCKS& param : _trid_6) { - Train_1_beebook_deterministic_MC_POR_v3::BLOCKS _tmp_1 = param; - - Train_1_beebook_deterministic_MC_POR_v3 copiedState = state._copy(); - Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_BACK_MOVE_2 readState = state._projected_state_for_BACK_MOVE_2(); - - auto _OpCache_with_parameter_BACK_MOVE_2_ptr = _OpCache_BACK_MOVE_2.find(param); - if(_OpCache_with_parameter_BACK_MOVE_2_ptr == _OpCache_BACK_MOVE_2.end()) { + } else { + std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_BACK_MOVE_2, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_BACK_MOVE_2, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_BACK_MOVE_2::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_BACK_MOVE_2::HashEqual> _OpCache_with_parameter_BACK_MOVE_2 = _OpCache_with_parameter_BACK_MOVE_2_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_BACK_MOVE_2.find(readState); + if(writeState_ptr != _OpCache_with_parameter_BACK_MOVE_2.end()) { + Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_BACK_MOVE_2 writeState = writeState_ptr->second; + copiedState._apply_update_for_BACK_MOVE_2(writeState); + } else { copiedState.BACK_MOVE_2(_tmp_1); Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_BACK_MOVE_2 writeState = copiedState._update_for_BACK_MOVE_2(); - std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_BACK_MOVE_2, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_BACK_MOVE_2, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_BACK_MOVE_2::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_BACK_MOVE_2::HashEqual> _OpCache_with_parameter_BACK_MOVE_2; - _OpCache_with_parameter_BACK_MOVE_2.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_BACK_MOVE_2_lock(_ProjectionRead_BACK_MOVE_2_mutex); - _OpCache_BACK_MOVE_2.insert({param, _OpCache_with_parameter_BACK_MOVE_2}); - } - - } else { - std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_BACK_MOVE_2, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_BACK_MOVE_2, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_BACK_MOVE_2::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_BACK_MOVE_2::HashEqual> _OpCache_with_parameter_BACK_MOVE_2 = _OpCache_with_parameter_BACK_MOVE_2_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_BACK_MOVE_2.find(readState); - if(writeState_ptr != _OpCache_with_parameter_BACK_MOVE_2.end()) { - Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_BACK_MOVE_2 writeState = writeState_ptr->second; - copiedState._apply_update_for_BACK_MOVE_2(writeState); - } else { - copiedState.BACK_MOVE_2(_tmp_1); - Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_BACK_MOVE_2 writeState = copiedState._update_for_BACK_MOVE_2(); - { - std::unique_lock<std::mutex> _ProjectionRead_BACK_MOVE_2_lock(_ProjectionRead_BACK_MOVE_2_mutex); - _OpCache_with_parameter_BACK_MOVE_2.insert({readState, writeState}); - } + _OpCache_with_parameter_BACK_MOVE_2.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "BACK_MOVE_2"; - result.insert(copiedState); + copiedState.stateAccessedVia = "BACK_MOVE_2"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead__tr_point_positionning read__tr_point_positionning_state = state._projected_state_for__tr_point_positionning(); + BSet<Train_1_beebook_deterministic_MC_POR_v3::ROUTES> _trid_7; auto _trid_7_ptr = _OpCache_tr_point_positionning.find(read__tr_point_positionning_state); if(_trid_7_ptr == _OpCache_tr_point_positionning.end()) { - BSet<Train_1_beebook_deterministic_MC_POR_v3::ROUTES> _trid_7 = state._tr_point_positionning(); + _trid_7 = state._tr_point_positionning(); { std::unique_lock<std::mutex> _ProjectionRead__tr_point_positionning_lock(_ProjectionRead__tr_point_positionning_mutex); _OpCache_tr_point_positionning.insert({read__tr_point_positionning_state, _trid_7}); } - for(const Train_1_beebook_deterministic_MC_POR_v3::ROUTES& param : _trid_7) { - Train_1_beebook_deterministic_MC_POR_v3::ROUTES _tmp_1 = param; - - Train_1_beebook_deterministic_MC_POR_v3 copiedState = state._copy(); - Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_point_positionning readState = state._projected_state_for_point_positionning(); + } else { + _trid_7 = _trid_7_ptr->second; + } - auto _OpCache_with_parameter_point_positionning_ptr = _OpCache_point_positionning.find(param); - if(_OpCache_with_parameter_point_positionning_ptr == _OpCache_point_positionning.end()) { - copiedState.point_positionning(_tmp_1); - Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_point_positionning writeState = copiedState._update_for_point_positionning(); - std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_point_positionning, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_point_positionning, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_point_positionning::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_point_positionning::HashEqual> _OpCache_with_parameter_point_positionning; - _OpCache_with_parameter_point_positionning.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_point_positionning_lock(_ProjectionRead_point_positionning_mutex); - _OpCache_point_positionning.insert({param, _OpCache_with_parameter_point_positionning}); - } + for(const Train_1_beebook_deterministic_MC_POR_v3::ROUTES& param : _trid_7) { + Train_1_beebook_deterministic_MC_POR_v3::ROUTES _tmp_1 = param; - } else { - std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_point_positionning, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_point_positionning, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_point_positionning::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_point_positionning::HashEqual> _OpCache_with_parameter_point_positionning = _OpCache_with_parameter_point_positionning_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_point_positionning.find(readState); - if(writeState_ptr != _OpCache_with_parameter_point_positionning.end()) { - Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_point_positionning writeState = writeState_ptr->second; - copiedState._apply_update_for_point_positionning(writeState); - } else { - copiedState.point_positionning(_tmp_1); - Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_point_positionning writeState = copiedState._update_for_point_positionning(); - { - std::unique_lock<std::mutex> _ProjectionRead_point_positionning_lock(_ProjectionRead_point_positionning_mutex); - _OpCache_with_parameter_point_positionning.insert({readState, writeState}); - } - } + Train_1_beebook_deterministic_MC_POR_v3 copiedState = state._copy(); + Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_point_positionning readState = state._projected_state_for_point_positionning(); + + auto _OpCache_with_parameter_point_positionning_ptr = _OpCache_point_positionning.find(param); + if(_OpCache_with_parameter_point_positionning_ptr == _OpCache_point_positionning.end()) { + copiedState.point_positionning(_tmp_1); + Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_point_positionning writeState = copiedState._update_for_point_positionning(); + std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_point_positionning, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_point_positionning, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_point_positionning::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_point_positionning::HashEqual> _OpCache_with_parameter_point_positionning; + _OpCache_with_parameter_point_positionning.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_point_positionning_lock(_ProjectionRead_point_positionning_mutex); + _OpCache_point_positionning.insert({param, _OpCache_with_parameter_point_positionning}); } - copiedState.stateAccessedVia = "point_positionning"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<Train_1_beebook_deterministic_MC_POR_v3::ROUTES> _trid_7 = _trid_7_ptr->second; - for(const Train_1_beebook_deterministic_MC_POR_v3::ROUTES& param : _trid_7) { - Train_1_beebook_deterministic_MC_POR_v3::ROUTES _tmp_1 = param; - - Train_1_beebook_deterministic_MC_POR_v3 copiedState = state._copy(); - Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_point_positionning readState = state._projected_state_for_point_positionning(); - - auto _OpCache_with_parameter_point_positionning_ptr = _OpCache_point_positionning.find(param); - if(_OpCache_with_parameter_point_positionning_ptr == _OpCache_point_positionning.end()) { + } else { + std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_point_positionning, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_point_positionning, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_point_positionning::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_point_positionning::HashEqual> _OpCache_with_parameter_point_positionning = _OpCache_with_parameter_point_positionning_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_point_positionning.find(readState); + if(writeState_ptr != _OpCache_with_parameter_point_positionning.end()) { + Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_point_positionning writeState = writeState_ptr->second; + copiedState._apply_update_for_point_positionning(writeState); + } else { copiedState.point_positionning(_tmp_1); Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_point_positionning writeState = copiedState._update_for_point_positionning(); - std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_point_positionning, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_point_positionning, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_point_positionning::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_point_positionning::HashEqual> _OpCache_with_parameter_point_positionning; - _OpCache_with_parameter_point_positionning.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_point_positionning_lock(_ProjectionRead_point_positionning_mutex); - _OpCache_point_positionning.insert({param, _OpCache_with_parameter_point_positionning}); - } - - } else { - std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_point_positionning, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_point_positionning, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_point_positionning::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_point_positionning::HashEqual> _OpCache_with_parameter_point_positionning = _OpCache_with_parameter_point_positionning_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_point_positionning.find(readState); - if(writeState_ptr != _OpCache_with_parameter_point_positionning.end()) { - Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_point_positionning writeState = writeState_ptr->second; - copiedState._apply_update_for_point_positionning(writeState); - } else { - copiedState.point_positionning(_tmp_1); - Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_point_positionning writeState = copiedState._update_for_point_positionning(); - { - std::unique_lock<std::mutex> _ProjectionRead_point_positionning_lock(_ProjectionRead_point_positionning_mutex); - _OpCache_with_parameter_point_positionning.insert({readState, writeState}); - } + _OpCache_with_parameter_point_positionning.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "point_positionning"; - result.insert(copiedState); + copiedState.stateAccessedVia = "point_positionning"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead__tr_route_formation read__tr_route_formation_state = state._projected_state_for__tr_route_formation(); + BSet<Train_1_beebook_deterministic_MC_POR_v3::ROUTES> _trid_8; auto _trid_8_ptr = _OpCache_tr_route_formation.find(read__tr_route_formation_state); if(_trid_8_ptr == _OpCache_tr_route_formation.end()) { - BSet<Train_1_beebook_deterministic_MC_POR_v3::ROUTES> _trid_8 = state._tr_route_formation(); + _trid_8 = state._tr_route_formation(); { std::unique_lock<std::mutex> _ProjectionRead__tr_route_formation_lock(_ProjectionRead__tr_route_formation_mutex); _OpCache_tr_route_formation.insert({read__tr_route_formation_state, _trid_8}); } - for(const Train_1_beebook_deterministic_MC_POR_v3::ROUTES& param : _trid_8) { - Train_1_beebook_deterministic_MC_POR_v3::ROUTES _tmp_1 = param; - - Train_1_beebook_deterministic_MC_POR_v3 copiedState = state._copy(); - Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_formation readState = state._projected_state_for_route_formation(); + } else { + _trid_8 = _trid_8_ptr->second; + } - auto _OpCache_with_parameter_route_formation_ptr = _OpCache_route_formation.find(param); - if(_OpCache_with_parameter_route_formation_ptr == _OpCache_route_formation.end()) { - copiedState.route_formation(_tmp_1); - Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_route_formation writeState = copiedState._update_for_route_formation(); - std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_formation, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_route_formation, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_formation::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_formation::HashEqual> _OpCache_with_parameter_route_formation; - _OpCache_with_parameter_route_formation.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_route_formation_lock(_ProjectionRead_route_formation_mutex); - _OpCache_route_formation.insert({param, _OpCache_with_parameter_route_formation}); - } + for(const Train_1_beebook_deterministic_MC_POR_v3::ROUTES& param : _trid_8) { + Train_1_beebook_deterministic_MC_POR_v3::ROUTES _tmp_1 = param; - } else { - std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_formation, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_route_formation, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_formation::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_formation::HashEqual> _OpCache_with_parameter_route_formation = _OpCache_with_parameter_route_formation_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_route_formation.find(readState); - if(writeState_ptr != _OpCache_with_parameter_route_formation.end()) { - Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_route_formation writeState = writeState_ptr->second; - copiedState._apply_update_for_route_formation(writeState); - } else { - copiedState.route_formation(_tmp_1); - Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_route_formation writeState = copiedState._update_for_route_formation(); - { - std::unique_lock<std::mutex> _ProjectionRead_route_formation_lock(_ProjectionRead_route_formation_mutex); - _OpCache_with_parameter_route_formation.insert({readState, writeState}); - } - } + Train_1_beebook_deterministic_MC_POR_v3 copiedState = state._copy(); + Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_formation readState = state._projected_state_for_route_formation(); + + auto _OpCache_with_parameter_route_formation_ptr = _OpCache_route_formation.find(param); + if(_OpCache_with_parameter_route_formation_ptr == _OpCache_route_formation.end()) { + copiedState.route_formation(_tmp_1); + Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_route_formation writeState = copiedState._update_for_route_formation(); + std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_formation, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_route_formation, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_formation::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_formation::HashEqual> _OpCache_with_parameter_route_formation; + _OpCache_with_parameter_route_formation.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_route_formation_lock(_ProjectionRead_route_formation_mutex); + _OpCache_route_formation.insert({param, _OpCache_with_parameter_route_formation}); } - copiedState.stateAccessedVia = "route_formation"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<Train_1_beebook_deterministic_MC_POR_v3::ROUTES> _trid_8 = _trid_8_ptr->second; - for(const Train_1_beebook_deterministic_MC_POR_v3::ROUTES& param : _trid_8) { - Train_1_beebook_deterministic_MC_POR_v3::ROUTES _tmp_1 = param; - - Train_1_beebook_deterministic_MC_POR_v3 copiedState = state._copy(); - Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_formation readState = state._projected_state_for_route_formation(); - - auto _OpCache_with_parameter_route_formation_ptr = _OpCache_route_formation.find(param); - if(_OpCache_with_parameter_route_formation_ptr == _OpCache_route_formation.end()) { + } else { + std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_formation, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_route_formation, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_formation::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_formation::HashEqual> _OpCache_with_parameter_route_formation = _OpCache_with_parameter_route_formation_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_route_formation.find(readState); + if(writeState_ptr != _OpCache_with_parameter_route_formation.end()) { + Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_route_formation writeState = writeState_ptr->second; + copiedState._apply_update_for_route_formation(writeState); + } else { copiedState.route_formation(_tmp_1); Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_route_formation writeState = copiedState._update_for_route_formation(); - std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_formation, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_route_formation, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_formation::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_formation::HashEqual> _OpCache_with_parameter_route_formation; - _OpCache_with_parameter_route_formation.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_route_formation_lock(_ProjectionRead_route_formation_mutex); - _OpCache_route_formation.insert({param, _OpCache_with_parameter_route_formation}); - } - - } else { - std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_formation, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_route_formation, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_formation::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_formation::HashEqual> _OpCache_with_parameter_route_formation = _OpCache_with_parameter_route_formation_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_route_formation.find(readState); - if(writeState_ptr != _OpCache_with_parameter_route_formation.end()) { - Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_route_formation writeState = writeState_ptr->second; - copiedState._apply_update_for_route_formation(writeState); - } else { - copiedState.route_formation(_tmp_1); - Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_route_formation writeState = copiedState._update_for_route_formation(); - { - std::unique_lock<std::mutex> _ProjectionRead_route_formation_lock(_ProjectionRead_route_formation_mutex); - _OpCache_with_parameter_route_formation.insert({readState, writeState}); - } + _OpCache_with_parameter_route_formation.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "route_formation"; - result.insert(copiedState); + copiedState.stateAccessedVia = "route_formation"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } @@ -4194,7 +3946,10 @@ class ModelChecker { copiedState.route_reservation(_tmp_1); copiedState.stateAccessedVia = "route_reservation"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<Train_1_beebook_deterministic_MC_POR_v3::ROUTES> _trid_2 = state._tr_route_freeing(); for(const Train_1_beebook_deterministic_MC_POR_v3::ROUTES& param : _trid_2) { @@ -4204,7 +3959,10 @@ class ModelChecker { copiedState.route_freeing(_tmp_1); copiedState.stateAccessedVia = "route_freeing"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<Train_1_beebook_deterministic_MC_POR_v3::ROUTES> _trid_3 = state._tr_FRONT_MOVE_1(); for(const Train_1_beebook_deterministic_MC_POR_v3::ROUTES& param : _trid_3) { @@ -4214,7 +3972,10 @@ class ModelChecker { copiedState.FRONT_MOVE_1(_tmp_1); copiedState.stateAccessedVia = "FRONT_MOVE_1"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<Train_1_beebook_deterministic_MC_POR_v3::BLOCKS> _trid_4 = state._tr_FRONT_MOVE_2(); for(const Train_1_beebook_deterministic_MC_POR_v3::BLOCKS& param : _trid_4) { @@ -4224,7 +3985,10 @@ class ModelChecker { copiedState.FRONT_MOVE_2(_tmp_1); copiedState.stateAccessedVia = "FRONT_MOVE_2"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<Train_1_beebook_deterministic_MC_POR_v3::BLOCKS> _trid_5 = state._tr_BACK_MOVE_1(); for(const Train_1_beebook_deterministic_MC_POR_v3::BLOCKS& param : _trid_5) { @@ -4234,7 +3998,10 @@ class ModelChecker { copiedState.BACK_MOVE_1(_tmp_1); copiedState.stateAccessedVia = "BACK_MOVE_1"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<Train_1_beebook_deterministic_MC_POR_v3::BLOCKS> _trid_6 = state._tr_BACK_MOVE_2(); for(const Train_1_beebook_deterministic_MC_POR_v3::BLOCKS& param : _trid_6) { @@ -4244,7 +4011,10 @@ class ModelChecker { copiedState.BACK_MOVE_2(_tmp_1); copiedState.stateAccessedVia = "BACK_MOVE_2"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<Train_1_beebook_deterministic_MC_POR_v3::ROUTES> _trid_7 = state._tr_point_positionning(); for(const Train_1_beebook_deterministic_MC_POR_v3::ROUTES& param : _trid_7) { @@ -4254,7 +4024,10 @@ class ModelChecker { copiedState.point_positionning(_tmp_1); copiedState.stateAccessedVia = "point_positionning"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<Train_1_beebook_deterministic_MC_POR_v3::ROUTES> _trid_8 = state._tr_route_formation(); for(const Train_1_beebook_deterministic_MC_POR_v3::ROUTES& param : _trid_8) { @@ -4264,7 +4037,10 @@ class ModelChecker { copiedState.route_formation(_tmp_1); copiedState.stateAccessedVia = "route_formation"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } } diff --git a/benchmarks/model_checking_opreuse/C++/nota_v2.cpp b/benchmarks/model_checking_opreuse/C++/nota_v2.cpp index df438e389753e9f980ad5f9d8403b0d4a451b49c..76d0f602d778388becab3cc7c732934806408c21 100644 --- a/benchmarks/model_checking_opreuse/C++/nota_v2.cpp +++ b/benchmarks/model_checking_opreuse/C++/nota_v2.cpp @@ -10,7 +10,6 @@ #include <atomic> #include <any> #include <mutex> -#include <shared_mutex> #include <future> #include <boost/asio/post.hpp> #include <boost/asio/thread_pool.hpp> @@ -5261,12 +5260,16 @@ class ModelChecker { states.insert(machine); unvisitedStates.push_back(machine); - std::atomic<bool> stopThreads(false); + std::atomic<bool> stopThreads; + stopThreads = false; std::atomic<int> possibleQueueChanges; possibleQueueChanges = 0; - while(!unvisitedStates.empty() && !stopThreads.load()) { - possibleQueueChanges.fetch_add(1); + std::atomic<bool> waitFlag; + waitFlag = true; + + while(!unvisitedStates.empty() && !stopThreads) { + possibleQueueChanges += 1; nota_v2 state = next(); std::packaged_task<void()> task([&, state] { std::unordered_set<nota_v2, nota_v2::Hash, nota_v2::HashEqual> nextStates = generateNextStates(state); @@ -5287,12 +5290,14 @@ class ModelChecker { } } - possibleQueueChanges.fetch_sub(1); { std::unique_lock<std::mutex> lock(mutex); - if (!unvisitedStates.empty() || possibleQueueChanges.load() == 0) { + possibleQueueChanges -= 1; + int running = possibleQueueChanges; + if (!unvisitedStates.empty() || running == 0) { { std::unique_lock<std::mutex> lock(waitMutex); + waitFlag = false; waitCV.notify_one(); } } @@ -5302,24 +5307,27 @@ class ModelChecker { if(invariantViolated(state)) { invariantViolatedBool = true; counterExampleState = state; - stopThreads.store(true); + stopThreads = true; } if(nextStates.empty()) { deadlockDetected = true; counterExampleState = state; - stopThreads.store(true); + stopThreads = true; } }); + waitFlag = true; boost::asio::post(workers, std::move(task)); { std::unique_lock<std::mutex> lock(waitMutex); - waitCV.wait(lock, [&] { - return !unvisitedStates.empty() || possibleQueueChanges == 0; - }); + if(unvisitedStates.empty() && possibleQueueChanges > 0) { + waitCV.wait(lock, [&] { + return waitFlag == false; + }); + } } } workers.join(); @@ -5364,1262 +5372,779 @@ class ModelChecker { std::unordered_set<nota_v2, nota_v2::Hash, nota_v2::HashEqual> result = std::unordered_set<nota_v2, nota_v2::Hash, nota_v2::HashEqual>(); if(isCaching) { nota_v2::_ProjectionRead__tr_constructor_interconnectNode read__tr_constructor_interconnectNode_state = state._projected_state_for__tr_constructor_interconnectNode(); + BSet<nota_v2::INTERCONNECTNODE> _trid_1; auto _trid_1_ptr = _OpCache_tr_constructor_interconnectNode.find(read__tr_constructor_interconnectNode_state); if(_trid_1_ptr == _OpCache_tr_constructor_interconnectNode.end()) { - BSet<nota_v2::INTERCONNECTNODE> _trid_1 = state._tr_constructor_interconnectNode(); + _trid_1 = state._tr_constructor_interconnectNode(); { std::unique_lock<std::mutex> _ProjectionRead__tr_constructor_interconnectNode_lock(_ProjectionRead__tr_constructor_interconnectNode_mutex); _OpCache_tr_constructor_interconnectNode.insert({read__tr_constructor_interconnectNode_state, _trid_1}); } - for(const nota_v2::INTERCONNECTNODE& param : _trid_1) { - nota_v2::INTERCONNECTNODE _tmp_1 = param; - - nota_v2 copiedState = state._copy(); - nota_v2::_ProjectionRead_constructor_interconnectNode readState = state._projected_state_for_constructor_interconnectNode(); + } else { + _trid_1 = _trid_1_ptr->second; + } - auto _OpCache_with_parameter_constructor_interconnectNode_ptr = _OpCache_constructor_interconnectNode.find(param); - if(_OpCache_with_parameter_constructor_interconnectNode_ptr == _OpCache_constructor_interconnectNode.end()) { - copiedState.constructor_interconnectNode(_tmp_1); - nota_v2::_ProjectionWrite_constructor_interconnectNode writeState = copiedState._update_for_constructor_interconnectNode(); - std::unordered_map<nota_v2::_ProjectionRead_constructor_interconnectNode, nota_v2::_ProjectionWrite_constructor_interconnectNode, nota_v2::_ProjectionRead_constructor_interconnectNode::Hash, nota_v2::_ProjectionRead_constructor_interconnectNode::HashEqual> _OpCache_with_parameter_constructor_interconnectNode; - _OpCache_with_parameter_constructor_interconnectNode.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_constructor_interconnectNode_lock(_ProjectionRead_constructor_interconnectNode_mutex); - _OpCache_constructor_interconnectNode.insert({param, _OpCache_with_parameter_constructor_interconnectNode}); - } + for(const nota_v2::INTERCONNECTNODE& param : _trid_1) { + nota_v2::INTERCONNECTNODE _tmp_1 = param; - } else { - std::unordered_map<nota_v2::_ProjectionRead_constructor_interconnectNode, nota_v2::_ProjectionWrite_constructor_interconnectNode, nota_v2::_ProjectionRead_constructor_interconnectNode::Hash, nota_v2::_ProjectionRead_constructor_interconnectNode::HashEqual> _OpCache_with_parameter_constructor_interconnectNode = _OpCache_with_parameter_constructor_interconnectNode_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_constructor_interconnectNode.find(readState); - if(writeState_ptr != _OpCache_with_parameter_constructor_interconnectNode.end()) { - nota_v2::_ProjectionWrite_constructor_interconnectNode writeState = writeState_ptr->second; - copiedState._apply_update_for_constructor_interconnectNode(writeState); - } else { - copiedState.constructor_interconnectNode(_tmp_1); - nota_v2::_ProjectionWrite_constructor_interconnectNode writeState = copiedState._update_for_constructor_interconnectNode(); - { - std::unique_lock<std::mutex> _ProjectionRead_constructor_interconnectNode_lock(_ProjectionRead_constructor_interconnectNode_mutex); - _OpCache_with_parameter_constructor_interconnectNode.insert({readState, writeState}); - } - } + nota_v2 copiedState = state._copy(); + nota_v2::_ProjectionRead_constructor_interconnectNode readState = state._projected_state_for_constructor_interconnectNode(); + + auto _OpCache_with_parameter_constructor_interconnectNode_ptr = _OpCache_constructor_interconnectNode.find(param); + if(_OpCache_with_parameter_constructor_interconnectNode_ptr == _OpCache_constructor_interconnectNode.end()) { + copiedState.constructor_interconnectNode(_tmp_1); + nota_v2::_ProjectionWrite_constructor_interconnectNode writeState = copiedState._update_for_constructor_interconnectNode(); + std::unordered_map<nota_v2::_ProjectionRead_constructor_interconnectNode, nota_v2::_ProjectionWrite_constructor_interconnectNode, nota_v2::_ProjectionRead_constructor_interconnectNode::Hash, nota_v2::_ProjectionRead_constructor_interconnectNode::HashEqual> _OpCache_with_parameter_constructor_interconnectNode; + _OpCache_with_parameter_constructor_interconnectNode.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_constructor_interconnectNode_lock(_ProjectionRead_constructor_interconnectNode_mutex); + _OpCache_constructor_interconnectNode.insert({param, _OpCache_with_parameter_constructor_interconnectNode}); } - copiedState.stateAccessedVia = "constructor_interconnectNode"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<nota_v2::INTERCONNECTNODE> _trid_1 = _trid_1_ptr->second; - for(const nota_v2::INTERCONNECTNODE& param : _trid_1) { - nota_v2::INTERCONNECTNODE _tmp_1 = param; - - nota_v2 copiedState = state._copy(); - nota_v2::_ProjectionRead_constructor_interconnectNode readState = state._projected_state_for_constructor_interconnectNode(); - - auto _OpCache_with_parameter_constructor_interconnectNode_ptr = _OpCache_constructor_interconnectNode.find(param); - if(_OpCache_with_parameter_constructor_interconnectNode_ptr == _OpCache_constructor_interconnectNode.end()) { + } else { + std::unordered_map<nota_v2::_ProjectionRead_constructor_interconnectNode, nota_v2::_ProjectionWrite_constructor_interconnectNode, nota_v2::_ProjectionRead_constructor_interconnectNode::Hash, nota_v2::_ProjectionRead_constructor_interconnectNode::HashEqual> _OpCache_with_parameter_constructor_interconnectNode = _OpCache_with_parameter_constructor_interconnectNode_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_constructor_interconnectNode.find(readState); + if(writeState_ptr != _OpCache_with_parameter_constructor_interconnectNode.end()) { + nota_v2::_ProjectionWrite_constructor_interconnectNode writeState = writeState_ptr->second; + copiedState._apply_update_for_constructor_interconnectNode(writeState); + } else { copiedState.constructor_interconnectNode(_tmp_1); nota_v2::_ProjectionWrite_constructor_interconnectNode writeState = copiedState._update_for_constructor_interconnectNode(); - std::unordered_map<nota_v2::_ProjectionRead_constructor_interconnectNode, nota_v2::_ProjectionWrite_constructor_interconnectNode, nota_v2::_ProjectionRead_constructor_interconnectNode::Hash, nota_v2::_ProjectionRead_constructor_interconnectNode::HashEqual> _OpCache_with_parameter_constructor_interconnectNode; - _OpCache_with_parameter_constructor_interconnectNode.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_constructor_interconnectNode_lock(_ProjectionRead_constructor_interconnectNode_mutex); - _OpCache_constructor_interconnectNode.insert({param, _OpCache_with_parameter_constructor_interconnectNode}); - } - - } else { - std::unordered_map<nota_v2::_ProjectionRead_constructor_interconnectNode, nota_v2::_ProjectionWrite_constructor_interconnectNode, nota_v2::_ProjectionRead_constructor_interconnectNode::Hash, nota_v2::_ProjectionRead_constructor_interconnectNode::HashEqual> _OpCache_with_parameter_constructor_interconnectNode = _OpCache_with_parameter_constructor_interconnectNode_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_constructor_interconnectNode.find(readState); - if(writeState_ptr != _OpCache_with_parameter_constructor_interconnectNode.end()) { - nota_v2::_ProjectionWrite_constructor_interconnectNode writeState = writeState_ptr->second; - copiedState._apply_update_for_constructor_interconnectNode(writeState); - } else { - copiedState.constructor_interconnectNode(_tmp_1); - nota_v2::_ProjectionWrite_constructor_interconnectNode writeState = copiedState._update_for_constructor_interconnectNode(); - { - std::unique_lock<std::mutex> _ProjectionRead_constructor_interconnectNode_lock(_ProjectionRead_constructor_interconnectNode_mutex); - _OpCache_with_parameter_constructor_interconnectNode.insert({readState, writeState}); - } + _OpCache_with_parameter_constructor_interconnectNode.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "constructor_interconnectNode"; - result.insert(copiedState); + copiedState.stateAccessedVia = "constructor_interconnectNode"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } nota_v2::_ProjectionRead__tr_constructor_resourceManager read__tr_constructor_resourceManager_state = state._projected_state_for__tr_constructor_resourceManager(); + BSet<nota_v2::RESOURCEMANAGER> _trid_2; auto _trid_2_ptr = _OpCache_tr_constructor_resourceManager.find(read__tr_constructor_resourceManager_state); if(_trid_2_ptr == _OpCache_tr_constructor_resourceManager.end()) { - BSet<nota_v2::RESOURCEMANAGER> _trid_2 = state._tr_constructor_resourceManager(); + _trid_2 = state._tr_constructor_resourceManager(); { std::unique_lock<std::mutex> _ProjectionRead__tr_constructor_resourceManager_lock(_ProjectionRead__tr_constructor_resourceManager_mutex); _OpCache_tr_constructor_resourceManager.insert({read__tr_constructor_resourceManager_state, _trid_2}); } - for(const nota_v2::RESOURCEMANAGER& param : _trid_2) { - nota_v2::RESOURCEMANAGER _tmp_1 = param; - - nota_v2 copiedState = state._copy(); - nota_v2::_ProjectionRead_constructor_resourceManager readState = state._projected_state_for_constructor_resourceManager(); + } else { + _trid_2 = _trid_2_ptr->second; + } - auto _OpCache_with_parameter_constructor_resourceManager_ptr = _OpCache_constructor_resourceManager.find(param); - if(_OpCache_with_parameter_constructor_resourceManager_ptr == _OpCache_constructor_resourceManager.end()) { - copiedState.constructor_resourceManager(_tmp_1); - nota_v2::_ProjectionWrite_constructor_resourceManager writeState = copiedState._update_for_constructor_resourceManager(); - std::unordered_map<nota_v2::_ProjectionRead_constructor_resourceManager, nota_v2::_ProjectionWrite_constructor_resourceManager, nota_v2::_ProjectionRead_constructor_resourceManager::Hash, nota_v2::_ProjectionRead_constructor_resourceManager::HashEqual> _OpCache_with_parameter_constructor_resourceManager; - _OpCache_with_parameter_constructor_resourceManager.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_constructor_resourceManager_lock(_ProjectionRead_constructor_resourceManager_mutex); - _OpCache_constructor_resourceManager.insert({param, _OpCache_with_parameter_constructor_resourceManager}); - } + for(const nota_v2::RESOURCEMANAGER& param : _trid_2) { + nota_v2::RESOURCEMANAGER _tmp_1 = param; - } else { - std::unordered_map<nota_v2::_ProjectionRead_constructor_resourceManager, nota_v2::_ProjectionWrite_constructor_resourceManager, nota_v2::_ProjectionRead_constructor_resourceManager::Hash, nota_v2::_ProjectionRead_constructor_resourceManager::HashEqual> _OpCache_with_parameter_constructor_resourceManager = _OpCache_with_parameter_constructor_resourceManager_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_constructor_resourceManager.find(readState); - if(writeState_ptr != _OpCache_with_parameter_constructor_resourceManager.end()) { - nota_v2::_ProjectionWrite_constructor_resourceManager writeState = writeState_ptr->second; - copiedState._apply_update_for_constructor_resourceManager(writeState); - } else { - copiedState.constructor_resourceManager(_tmp_1); - nota_v2::_ProjectionWrite_constructor_resourceManager writeState = copiedState._update_for_constructor_resourceManager(); - { - std::unique_lock<std::mutex> _ProjectionRead_constructor_resourceManager_lock(_ProjectionRead_constructor_resourceManager_mutex); - _OpCache_with_parameter_constructor_resourceManager.insert({readState, writeState}); - } - } + nota_v2 copiedState = state._copy(); + nota_v2::_ProjectionRead_constructor_resourceManager readState = state._projected_state_for_constructor_resourceManager(); + + auto _OpCache_with_parameter_constructor_resourceManager_ptr = _OpCache_constructor_resourceManager.find(param); + if(_OpCache_with_parameter_constructor_resourceManager_ptr == _OpCache_constructor_resourceManager.end()) { + copiedState.constructor_resourceManager(_tmp_1); + nota_v2::_ProjectionWrite_constructor_resourceManager writeState = copiedState._update_for_constructor_resourceManager(); + std::unordered_map<nota_v2::_ProjectionRead_constructor_resourceManager, nota_v2::_ProjectionWrite_constructor_resourceManager, nota_v2::_ProjectionRead_constructor_resourceManager::Hash, nota_v2::_ProjectionRead_constructor_resourceManager::HashEqual> _OpCache_with_parameter_constructor_resourceManager; + _OpCache_with_parameter_constructor_resourceManager.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_constructor_resourceManager_lock(_ProjectionRead_constructor_resourceManager_mutex); + _OpCache_constructor_resourceManager.insert({param, _OpCache_with_parameter_constructor_resourceManager}); } - copiedState.stateAccessedVia = "constructor_resourceManager"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<nota_v2::RESOURCEMANAGER> _trid_2 = _trid_2_ptr->second; - for(const nota_v2::RESOURCEMANAGER& param : _trid_2) { - nota_v2::RESOURCEMANAGER _tmp_1 = param; - - nota_v2 copiedState = state._copy(); - nota_v2::_ProjectionRead_constructor_resourceManager readState = state._projected_state_for_constructor_resourceManager(); - - auto _OpCache_with_parameter_constructor_resourceManager_ptr = _OpCache_constructor_resourceManager.find(param); - if(_OpCache_with_parameter_constructor_resourceManager_ptr == _OpCache_constructor_resourceManager.end()) { + } else { + std::unordered_map<nota_v2::_ProjectionRead_constructor_resourceManager, nota_v2::_ProjectionWrite_constructor_resourceManager, nota_v2::_ProjectionRead_constructor_resourceManager::Hash, nota_v2::_ProjectionRead_constructor_resourceManager::HashEqual> _OpCache_with_parameter_constructor_resourceManager = _OpCache_with_parameter_constructor_resourceManager_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_constructor_resourceManager.find(readState); + if(writeState_ptr != _OpCache_with_parameter_constructor_resourceManager.end()) { + nota_v2::_ProjectionWrite_constructor_resourceManager writeState = writeState_ptr->second; + copiedState._apply_update_for_constructor_resourceManager(writeState); + } else { copiedState.constructor_resourceManager(_tmp_1); nota_v2::_ProjectionWrite_constructor_resourceManager writeState = copiedState._update_for_constructor_resourceManager(); - std::unordered_map<nota_v2::_ProjectionRead_constructor_resourceManager, nota_v2::_ProjectionWrite_constructor_resourceManager, nota_v2::_ProjectionRead_constructor_resourceManager::Hash, nota_v2::_ProjectionRead_constructor_resourceManager::HashEqual> _OpCache_with_parameter_constructor_resourceManager; - _OpCache_with_parameter_constructor_resourceManager.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_constructor_resourceManager_lock(_ProjectionRead_constructor_resourceManager_mutex); - _OpCache_constructor_resourceManager.insert({param, _OpCache_with_parameter_constructor_resourceManager}); - } - - } else { - std::unordered_map<nota_v2::_ProjectionRead_constructor_resourceManager, nota_v2::_ProjectionWrite_constructor_resourceManager, nota_v2::_ProjectionRead_constructor_resourceManager::Hash, nota_v2::_ProjectionRead_constructor_resourceManager::HashEqual> _OpCache_with_parameter_constructor_resourceManager = _OpCache_with_parameter_constructor_resourceManager_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_constructor_resourceManager.find(readState); - if(writeState_ptr != _OpCache_with_parameter_constructor_resourceManager.end()) { - nota_v2::_ProjectionWrite_constructor_resourceManager writeState = writeState_ptr->second; - copiedState._apply_update_for_constructor_resourceManager(writeState); - } else { - copiedState.constructor_resourceManager(_tmp_1); - nota_v2::_ProjectionWrite_constructor_resourceManager writeState = copiedState._update_for_constructor_resourceManager(); - { - std::unique_lock<std::mutex> _ProjectionRead_constructor_resourceManager_lock(_ProjectionRead_constructor_resourceManager_mutex); - _OpCache_with_parameter_constructor_resourceManager.insert({readState, writeState}); - } + _OpCache_with_parameter_constructor_resourceManager.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "constructor_resourceManager"; - result.insert(copiedState); + copiedState.stateAccessedVia = "constructor_resourceManager"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } nota_v2::_ProjectionRead__tr_constructor_service read__tr_constructor_service_state = state._projected_state_for__tr_constructor_service(); + BSet<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::SERVICE >> _trid_3; auto _trid_3_ptr = _OpCache_tr_constructor_service.find(read__tr_constructor_service_state); if(_trid_3_ptr == _OpCache_tr_constructor_service.end()) { - BSet<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::SERVICE >> _trid_3 = state._tr_constructor_service(); + _trid_3 = state._tr_constructor_service(); { std::unique_lock<std::mutex> _ProjectionRead__tr_constructor_service_lock(_ProjectionRead__tr_constructor_service_mutex); _OpCache_tr_constructor_service.insert({read__tr_constructor_service_state, _trid_3}); } - for(const BTuple<nota_v2::INTERCONNECTNODE, nota_v2::SERVICE >& param : _trid_3) { - nota_v2::SERVICE _tmp_1 = param.projection2(); - nota_v2::INTERCONNECTNODE _tmp_2 = param.projection1(); - - nota_v2 copiedState = state._copy(); - nota_v2::_ProjectionRead_constructor_service readState = state._projected_state_for_constructor_service(); + } else { + _trid_3 = _trid_3_ptr->second; + } - auto _OpCache_with_parameter_constructor_service_ptr = _OpCache_constructor_service.find(param); - if(_OpCache_with_parameter_constructor_service_ptr == _OpCache_constructor_service.end()) { - copiedState.constructor_service(_tmp_2, _tmp_1); - nota_v2::_ProjectionWrite_constructor_service writeState = copiedState._update_for_constructor_service(); - std::unordered_map<nota_v2::_ProjectionRead_constructor_service, nota_v2::_ProjectionWrite_constructor_service, nota_v2::_ProjectionRead_constructor_service::Hash, nota_v2::_ProjectionRead_constructor_service::HashEqual> _OpCache_with_parameter_constructor_service; - _OpCache_with_parameter_constructor_service.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_constructor_service_lock(_ProjectionRead_constructor_service_mutex); - _OpCache_constructor_service.insert({param, _OpCache_with_parameter_constructor_service}); - } + for(const BTuple<nota_v2::INTERCONNECTNODE, nota_v2::SERVICE >& param : _trid_3) { + nota_v2::SERVICE _tmp_1 = param.projection2(); + nota_v2::INTERCONNECTNODE _tmp_2 = param.projection1(); - } else { - std::unordered_map<nota_v2::_ProjectionRead_constructor_service, nota_v2::_ProjectionWrite_constructor_service, nota_v2::_ProjectionRead_constructor_service::Hash, nota_v2::_ProjectionRead_constructor_service::HashEqual> _OpCache_with_parameter_constructor_service = _OpCache_with_parameter_constructor_service_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_constructor_service.find(readState); - if(writeState_ptr != _OpCache_with_parameter_constructor_service.end()) { - nota_v2::_ProjectionWrite_constructor_service writeState = writeState_ptr->second; - copiedState._apply_update_for_constructor_service(writeState); - } else { - copiedState.constructor_service(_tmp_2, _tmp_1); - nota_v2::_ProjectionWrite_constructor_service writeState = copiedState._update_for_constructor_service(); - { - std::unique_lock<std::mutex> _ProjectionRead_constructor_service_lock(_ProjectionRead_constructor_service_mutex); - _OpCache_with_parameter_constructor_service.insert({readState, writeState}); - } - } + nota_v2 copiedState = state._copy(); + nota_v2::_ProjectionRead_constructor_service readState = state._projected_state_for_constructor_service(); + + auto _OpCache_with_parameter_constructor_service_ptr = _OpCache_constructor_service.find(param); + if(_OpCache_with_parameter_constructor_service_ptr == _OpCache_constructor_service.end()) { + copiedState.constructor_service(_tmp_2, _tmp_1); + nota_v2::_ProjectionWrite_constructor_service writeState = copiedState._update_for_constructor_service(); + std::unordered_map<nota_v2::_ProjectionRead_constructor_service, nota_v2::_ProjectionWrite_constructor_service, nota_v2::_ProjectionRead_constructor_service::Hash, nota_v2::_ProjectionRead_constructor_service::HashEqual> _OpCache_with_parameter_constructor_service; + _OpCache_with_parameter_constructor_service.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_constructor_service_lock(_ProjectionRead_constructor_service_mutex); + _OpCache_constructor_service.insert({param, _OpCache_with_parameter_constructor_service}); } - copiedState.stateAccessedVia = "constructor_service"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::SERVICE >> _trid_3 = _trid_3_ptr->second; - for(const BTuple<nota_v2::INTERCONNECTNODE, nota_v2::SERVICE >& param : _trid_3) { - nota_v2::SERVICE _tmp_1 = param.projection2(); - nota_v2::INTERCONNECTNODE _tmp_2 = param.projection1(); - - nota_v2 copiedState = state._copy(); - nota_v2::_ProjectionRead_constructor_service readState = state._projected_state_for_constructor_service(); - - auto _OpCache_with_parameter_constructor_service_ptr = _OpCache_constructor_service.find(param); - if(_OpCache_with_parameter_constructor_service_ptr == _OpCache_constructor_service.end()) { + } else { + std::unordered_map<nota_v2::_ProjectionRead_constructor_service, nota_v2::_ProjectionWrite_constructor_service, nota_v2::_ProjectionRead_constructor_service::Hash, nota_v2::_ProjectionRead_constructor_service::HashEqual> _OpCache_with_parameter_constructor_service = _OpCache_with_parameter_constructor_service_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_constructor_service.find(readState); + if(writeState_ptr != _OpCache_with_parameter_constructor_service.end()) { + nota_v2::_ProjectionWrite_constructor_service writeState = writeState_ptr->second; + copiedState._apply_update_for_constructor_service(writeState); + } else { copiedState.constructor_service(_tmp_2, _tmp_1); nota_v2::_ProjectionWrite_constructor_service writeState = copiedState._update_for_constructor_service(); - std::unordered_map<nota_v2::_ProjectionRead_constructor_service, nota_v2::_ProjectionWrite_constructor_service, nota_v2::_ProjectionRead_constructor_service::Hash, nota_v2::_ProjectionRead_constructor_service::HashEqual> _OpCache_with_parameter_constructor_service; - _OpCache_with_parameter_constructor_service.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_constructor_service_lock(_ProjectionRead_constructor_service_mutex); - _OpCache_constructor_service.insert({param, _OpCache_with_parameter_constructor_service}); - } - - } else { - std::unordered_map<nota_v2::_ProjectionRead_constructor_service, nota_v2::_ProjectionWrite_constructor_service, nota_v2::_ProjectionRead_constructor_service::Hash, nota_v2::_ProjectionRead_constructor_service::HashEqual> _OpCache_with_parameter_constructor_service = _OpCache_with_parameter_constructor_service_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_constructor_service.find(readState); - if(writeState_ptr != _OpCache_with_parameter_constructor_service.end()) { - nota_v2::_ProjectionWrite_constructor_service writeState = writeState_ptr->second; - copiedState._apply_update_for_constructor_service(writeState); - } else { - copiedState.constructor_service(_tmp_2, _tmp_1); - nota_v2::_ProjectionWrite_constructor_service writeState = copiedState._update_for_constructor_service(); - { - std::unique_lock<std::mutex> _ProjectionRead_constructor_service_lock(_ProjectionRead_constructor_service_mutex); - _OpCache_with_parameter_constructor_service.insert({readState, writeState}); - } + _OpCache_with_parameter_constructor_service.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "constructor_service"; - result.insert(copiedState); + copiedState.stateAccessedVia = "constructor_service"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } nota_v2::_ProjectionRead__tr_constructor_socket read__tr_constructor_socket_state = state._projected_state_for__tr_constructor_socket(); + BSet<BTuple<BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::SID >, nota_v2::SID >, nota_v2::SOCKET >> _trid_4; auto _trid_4_ptr = _OpCache_tr_constructor_socket.find(read__tr_constructor_socket_state); if(_trid_4_ptr == _OpCache_tr_constructor_socket.end()) { - BSet<BTuple<BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::SID >, nota_v2::SID >, nota_v2::SOCKET >> _trid_4 = state._tr_constructor_socket(); + _trid_4 = state._tr_constructor_socket(); { std::unique_lock<std::mutex> _ProjectionRead__tr_constructor_socket_lock(_ProjectionRead__tr_constructor_socket_mutex); _OpCache_tr_constructor_socket.insert({read__tr_constructor_socket_state, _trid_4}); } - for(const BTuple<BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::SID >, nota_v2::SID >, nota_v2::SOCKET >& param : _trid_4) { - nota_v2::SOCKET _tmp_1 = param.projection2(); - BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::SID >, nota_v2::SID > _tmp_2 = param.projection1(); - nota_v2::SID _tmp_3 = _tmp_2.projection2(); - BTuple<nota_v2::INTERCONNECTNODE, nota_v2::SID > _tmp_4 = _tmp_2.projection1(); - nota_v2::SID _tmp_5 = _tmp_4.projection2(); - nota_v2::INTERCONNECTNODE _tmp_6 = _tmp_4.projection1(); - - nota_v2 copiedState = state._copy(); - nota_v2::_ProjectionRead_constructor_socket readState = state._projected_state_for_constructor_socket(); - - auto _OpCache_with_parameter_constructor_socket_ptr = _OpCache_constructor_socket.find(param); - if(_OpCache_with_parameter_constructor_socket_ptr == _OpCache_constructor_socket.end()) { - copiedState.constructor_socket(_tmp_6, _tmp_5, _tmp_3, _tmp_1); - nota_v2::_ProjectionWrite_constructor_socket writeState = copiedState._update_for_constructor_socket(); - std::unordered_map<nota_v2::_ProjectionRead_constructor_socket, nota_v2::_ProjectionWrite_constructor_socket, nota_v2::_ProjectionRead_constructor_socket::Hash, nota_v2::_ProjectionRead_constructor_socket::HashEqual> _OpCache_with_parameter_constructor_socket; - _OpCache_with_parameter_constructor_socket.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_constructor_socket_lock(_ProjectionRead_constructor_socket_mutex); - _OpCache_constructor_socket.insert({param, _OpCache_with_parameter_constructor_socket}); - } + } else { + _trid_4 = _trid_4_ptr->second; + } - } else { - std::unordered_map<nota_v2::_ProjectionRead_constructor_socket, nota_v2::_ProjectionWrite_constructor_socket, nota_v2::_ProjectionRead_constructor_socket::Hash, nota_v2::_ProjectionRead_constructor_socket::HashEqual> _OpCache_with_parameter_constructor_socket = _OpCache_with_parameter_constructor_socket_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_constructor_socket.find(readState); - if(writeState_ptr != _OpCache_with_parameter_constructor_socket.end()) { - nota_v2::_ProjectionWrite_constructor_socket writeState = writeState_ptr->second; - copiedState._apply_update_for_constructor_socket(writeState); - } else { - copiedState.constructor_socket(_tmp_6, _tmp_5, _tmp_3, _tmp_1); - nota_v2::_ProjectionWrite_constructor_socket writeState = copiedState._update_for_constructor_socket(); - { - std::unique_lock<std::mutex> _ProjectionRead_constructor_socket_lock(_ProjectionRead_constructor_socket_mutex); - _OpCache_with_parameter_constructor_socket.insert({readState, writeState}); - } - } + for(const BTuple<BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::SID >, nota_v2::SID >, nota_v2::SOCKET >& param : _trid_4) { + nota_v2::SOCKET _tmp_1 = param.projection2(); + BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::SID >, nota_v2::SID > _tmp_2 = param.projection1(); + nota_v2::SID _tmp_3 = _tmp_2.projection2(); + BTuple<nota_v2::INTERCONNECTNODE, nota_v2::SID > _tmp_4 = _tmp_2.projection1(); + nota_v2::SID _tmp_5 = _tmp_4.projection2(); + nota_v2::INTERCONNECTNODE _tmp_6 = _tmp_4.projection1(); + + nota_v2 copiedState = state._copy(); + nota_v2::_ProjectionRead_constructor_socket readState = state._projected_state_for_constructor_socket(); + + auto _OpCache_with_parameter_constructor_socket_ptr = _OpCache_constructor_socket.find(param); + if(_OpCache_with_parameter_constructor_socket_ptr == _OpCache_constructor_socket.end()) { + copiedState.constructor_socket(_tmp_6, _tmp_5, _tmp_3, _tmp_1); + nota_v2::_ProjectionWrite_constructor_socket writeState = copiedState._update_for_constructor_socket(); + std::unordered_map<nota_v2::_ProjectionRead_constructor_socket, nota_v2::_ProjectionWrite_constructor_socket, nota_v2::_ProjectionRead_constructor_socket::Hash, nota_v2::_ProjectionRead_constructor_socket::HashEqual> _OpCache_with_parameter_constructor_socket; + _OpCache_with_parameter_constructor_socket.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_constructor_socket_lock(_ProjectionRead_constructor_socket_mutex); + _OpCache_constructor_socket.insert({param, _OpCache_with_parameter_constructor_socket}); } - copiedState.stateAccessedVia = "constructor_socket"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<BTuple<BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::SID >, nota_v2::SID >, nota_v2::SOCKET >> _trid_4 = _trid_4_ptr->second; - for(const BTuple<BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::SID >, nota_v2::SID >, nota_v2::SOCKET >& param : _trid_4) { - nota_v2::SOCKET _tmp_1 = param.projection2(); - BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::SID >, nota_v2::SID > _tmp_2 = param.projection1(); - nota_v2::SID _tmp_3 = _tmp_2.projection2(); - BTuple<nota_v2::INTERCONNECTNODE, nota_v2::SID > _tmp_4 = _tmp_2.projection1(); - nota_v2::SID _tmp_5 = _tmp_4.projection2(); - nota_v2::INTERCONNECTNODE _tmp_6 = _tmp_4.projection1(); - - nota_v2 copiedState = state._copy(); - nota_v2::_ProjectionRead_constructor_socket readState = state._projected_state_for_constructor_socket(); - - auto _OpCache_with_parameter_constructor_socket_ptr = _OpCache_constructor_socket.find(param); - if(_OpCache_with_parameter_constructor_socket_ptr == _OpCache_constructor_socket.end()) { + } else { + std::unordered_map<nota_v2::_ProjectionRead_constructor_socket, nota_v2::_ProjectionWrite_constructor_socket, nota_v2::_ProjectionRead_constructor_socket::Hash, nota_v2::_ProjectionRead_constructor_socket::HashEqual> _OpCache_with_parameter_constructor_socket = _OpCache_with_parameter_constructor_socket_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_constructor_socket.find(readState); + if(writeState_ptr != _OpCache_with_parameter_constructor_socket.end()) { + nota_v2::_ProjectionWrite_constructor_socket writeState = writeState_ptr->second; + copiedState._apply_update_for_constructor_socket(writeState); + } else { copiedState.constructor_socket(_tmp_6, _tmp_5, _tmp_3, _tmp_1); nota_v2::_ProjectionWrite_constructor_socket writeState = copiedState._update_for_constructor_socket(); - std::unordered_map<nota_v2::_ProjectionRead_constructor_socket, nota_v2::_ProjectionWrite_constructor_socket, nota_v2::_ProjectionRead_constructor_socket::Hash, nota_v2::_ProjectionRead_constructor_socket::HashEqual> _OpCache_with_parameter_constructor_socket; - _OpCache_with_parameter_constructor_socket.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_constructor_socket_lock(_ProjectionRead_constructor_socket_mutex); - _OpCache_constructor_socket.insert({param, _OpCache_with_parameter_constructor_socket}); - } - - } else { - std::unordered_map<nota_v2::_ProjectionRead_constructor_socket, nota_v2::_ProjectionWrite_constructor_socket, nota_v2::_ProjectionRead_constructor_socket::Hash, nota_v2::_ProjectionRead_constructor_socket::HashEqual> _OpCache_with_parameter_constructor_socket = _OpCache_with_parameter_constructor_socket_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_constructor_socket.find(readState); - if(writeState_ptr != _OpCache_with_parameter_constructor_socket.end()) { - nota_v2::_ProjectionWrite_constructor_socket writeState = writeState_ptr->second; - copiedState._apply_update_for_constructor_socket(writeState); - } else { - copiedState.constructor_socket(_tmp_6, _tmp_5, _tmp_3, _tmp_1); - nota_v2::_ProjectionWrite_constructor_socket writeState = copiedState._update_for_constructor_socket(); - { - std::unique_lock<std::mutex> _ProjectionRead_constructor_socket_lock(_ProjectionRead_constructor_socket_mutex); - _OpCache_with_parameter_constructor_socket.insert({readState, writeState}); - } + _OpCache_with_parameter_constructor_socket.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "constructor_socket"; - result.insert(copiedState); + copiedState.stateAccessedVia = "constructor_socket"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } nota_v2::_ProjectionRead__tr_rm_register read__tr_rm_register_state = state._projected_state_for__tr_rm_register(); + BSet<BTuple<BTuple<nota_v2::RESOURCEMANAGER, nota_v2::SERVICE >, nota_v2::INTERCONNECTNODE >> _trid_5; auto _trid_5_ptr = _OpCache_tr_rm_register.find(read__tr_rm_register_state); if(_trid_5_ptr == _OpCache_tr_rm_register.end()) { - BSet<BTuple<BTuple<nota_v2::RESOURCEMANAGER, nota_v2::SERVICE >, nota_v2::INTERCONNECTNODE >> _trid_5 = state._tr_rm_register(); + _trid_5 = state._tr_rm_register(); { std::unique_lock<std::mutex> _ProjectionRead__tr_rm_register_lock(_ProjectionRead__tr_rm_register_mutex); _OpCache_tr_rm_register.insert({read__tr_rm_register_state, _trid_5}); } - for(const BTuple<BTuple<nota_v2::RESOURCEMANAGER, nota_v2::SERVICE >, nota_v2::INTERCONNECTNODE >& param : _trid_5) { - nota_v2::INTERCONNECTNODE _tmp_1 = param.projection2(); - BTuple<nota_v2::RESOURCEMANAGER, nota_v2::SERVICE > _tmp_2 = param.projection1(); - nota_v2::SERVICE _tmp_3 = _tmp_2.projection2(); - nota_v2::RESOURCEMANAGER _tmp_4 = _tmp_2.projection1(); - - nota_v2 copiedState = state._copy(); - nota_v2::_ProjectionRead_rm_register readState = state._projected_state_for_rm_register(); + } else { + _trid_5 = _trid_5_ptr->second; + } - auto _OpCache_with_parameter_rm_register_ptr = _OpCache_rm_register.find(param); - if(_OpCache_with_parameter_rm_register_ptr == _OpCache_rm_register.end()) { - copiedState.rm_register(_tmp_4, _tmp_3, _tmp_1); - nota_v2::_ProjectionWrite_rm_register writeState = copiedState._update_for_rm_register(); - std::unordered_map<nota_v2::_ProjectionRead_rm_register, nota_v2::_ProjectionWrite_rm_register, nota_v2::_ProjectionRead_rm_register::Hash, nota_v2::_ProjectionRead_rm_register::HashEqual> _OpCache_with_parameter_rm_register; - _OpCache_with_parameter_rm_register.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_rm_register_lock(_ProjectionRead_rm_register_mutex); - _OpCache_rm_register.insert({param, _OpCache_with_parameter_rm_register}); - } + for(const BTuple<BTuple<nota_v2::RESOURCEMANAGER, nota_v2::SERVICE >, nota_v2::INTERCONNECTNODE >& param : _trid_5) { + nota_v2::INTERCONNECTNODE _tmp_1 = param.projection2(); + BTuple<nota_v2::RESOURCEMANAGER, nota_v2::SERVICE > _tmp_2 = param.projection1(); + nota_v2::SERVICE _tmp_3 = _tmp_2.projection2(); + nota_v2::RESOURCEMANAGER _tmp_4 = _tmp_2.projection1(); - } else { - std::unordered_map<nota_v2::_ProjectionRead_rm_register, nota_v2::_ProjectionWrite_rm_register, nota_v2::_ProjectionRead_rm_register::Hash, nota_v2::_ProjectionRead_rm_register::HashEqual> _OpCache_with_parameter_rm_register = _OpCache_with_parameter_rm_register_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_rm_register.find(readState); - if(writeState_ptr != _OpCache_with_parameter_rm_register.end()) { - nota_v2::_ProjectionWrite_rm_register writeState = writeState_ptr->second; - copiedState._apply_update_for_rm_register(writeState); - } else { - copiedState.rm_register(_tmp_4, _tmp_3, _tmp_1); - nota_v2::_ProjectionWrite_rm_register writeState = copiedState._update_for_rm_register(); - { - std::unique_lock<std::mutex> _ProjectionRead_rm_register_lock(_ProjectionRead_rm_register_mutex); - _OpCache_with_parameter_rm_register.insert({readState, writeState}); - } - } + nota_v2 copiedState = state._copy(); + nota_v2::_ProjectionRead_rm_register readState = state._projected_state_for_rm_register(); + + auto _OpCache_with_parameter_rm_register_ptr = _OpCache_rm_register.find(param); + if(_OpCache_with_parameter_rm_register_ptr == _OpCache_rm_register.end()) { + copiedState.rm_register(_tmp_4, _tmp_3, _tmp_1); + nota_v2::_ProjectionWrite_rm_register writeState = copiedState._update_for_rm_register(); + std::unordered_map<nota_v2::_ProjectionRead_rm_register, nota_v2::_ProjectionWrite_rm_register, nota_v2::_ProjectionRead_rm_register::Hash, nota_v2::_ProjectionRead_rm_register::HashEqual> _OpCache_with_parameter_rm_register; + _OpCache_with_parameter_rm_register.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_rm_register_lock(_ProjectionRead_rm_register_mutex); + _OpCache_rm_register.insert({param, _OpCache_with_parameter_rm_register}); } - copiedState.stateAccessedVia = "rm_register"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<BTuple<BTuple<nota_v2::RESOURCEMANAGER, nota_v2::SERVICE >, nota_v2::INTERCONNECTNODE >> _trid_5 = _trid_5_ptr->second; - for(const BTuple<BTuple<nota_v2::RESOURCEMANAGER, nota_v2::SERVICE >, nota_v2::INTERCONNECTNODE >& param : _trid_5) { - nota_v2::INTERCONNECTNODE _tmp_1 = param.projection2(); - BTuple<nota_v2::RESOURCEMANAGER, nota_v2::SERVICE > _tmp_2 = param.projection1(); - nota_v2::SERVICE _tmp_3 = _tmp_2.projection2(); - nota_v2::RESOURCEMANAGER _tmp_4 = _tmp_2.projection1(); - - nota_v2 copiedState = state._copy(); - nota_v2::_ProjectionRead_rm_register readState = state._projected_state_for_rm_register(); - - auto _OpCache_with_parameter_rm_register_ptr = _OpCache_rm_register.find(param); - if(_OpCache_with_parameter_rm_register_ptr == _OpCache_rm_register.end()) { + } else { + std::unordered_map<nota_v2::_ProjectionRead_rm_register, nota_v2::_ProjectionWrite_rm_register, nota_v2::_ProjectionRead_rm_register::Hash, nota_v2::_ProjectionRead_rm_register::HashEqual> _OpCache_with_parameter_rm_register = _OpCache_with_parameter_rm_register_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_rm_register.find(readState); + if(writeState_ptr != _OpCache_with_parameter_rm_register.end()) { + nota_v2::_ProjectionWrite_rm_register writeState = writeState_ptr->second; + copiedState._apply_update_for_rm_register(writeState); + } else { copiedState.rm_register(_tmp_4, _tmp_3, _tmp_1); nota_v2::_ProjectionWrite_rm_register writeState = copiedState._update_for_rm_register(); - std::unordered_map<nota_v2::_ProjectionRead_rm_register, nota_v2::_ProjectionWrite_rm_register, nota_v2::_ProjectionRead_rm_register::Hash, nota_v2::_ProjectionRead_rm_register::HashEqual> _OpCache_with_parameter_rm_register; - _OpCache_with_parameter_rm_register.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_rm_register_lock(_ProjectionRead_rm_register_mutex); - _OpCache_rm_register.insert({param, _OpCache_with_parameter_rm_register}); - } - - } else { - std::unordered_map<nota_v2::_ProjectionRead_rm_register, nota_v2::_ProjectionWrite_rm_register, nota_v2::_ProjectionRead_rm_register::Hash, nota_v2::_ProjectionRead_rm_register::HashEqual> _OpCache_with_parameter_rm_register = _OpCache_with_parameter_rm_register_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_rm_register.find(readState); - if(writeState_ptr != _OpCache_with_parameter_rm_register.end()) { - nota_v2::_ProjectionWrite_rm_register writeState = writeState_ptr->second; - copiedState._apply_update_for_rm_register(writeState); - } else { - copiedState.rm_register(_tmp_4, _tmp_3, _tmp_1); - nota_v2::_ProjectionWrite_rm_register writeState = copiedState._update_for_rm_register(); - { - std::unique_lock<std::mutex> _ProjectionRead_rm_register_lock(_ProjectionRead_rm_register_mutex); - _OpCache_with_parameter_rm_register.insert({readState, writeState}); - } + _OpCache_with_parameter_rm_register.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "rm_register"; - result.insert(copiedState); + copiedState.stateAccessedVia = "rm_register"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } nota_v2::_ProjectionRead__tr_rm_deregister read__tr_rm_deregister_state = state._projected_state_for__tr_rm_deregister(); + BSet<BTuple<BTuple<nota_v2::RESOURCEMANAGER, nota_v2::SERVICE >, nota_v2::INTERCONNECTNODE >> _trid_6; auto _trid_6_ptr = _OpCache_tr_rm_deregister.find(read__tr_rm_deregister_state); if(_trid_6_ptr == _OpCache_tr_rm_deregister.end()) { - BSet<BTuple<BTuple<nota_v2::RESOURCEMANAGER, nota_v2::SERVICE >, nota_v2::INTERCONNECTNODE >> _trid_6 = state._tr_rm_deregister(); + _trid_6 = state._tr_rm_deregister(); { std::unique_lock<std::mutex> _ProjectionRead__tr_rm_deregister_lock(_ProjectionRead__tr_rm_deregister_mutex); _OpCache_tr_rm_deregister.insert({read__tr_rm_deregister_state, _trid_6}); } - for(const BTuple<BTuple<nota_v2::RESOURCEMANAGER, nota_v2::SERVICE >, nota_v2::INTERCONNECTNODE >& param : _trid_6) { - nota_v2::INTERCONNECTNODE _tmp_1 = param.projection2(); - BTuple<nota_v2::RESOURCEMANAGER, nota_v2::SERVICE > _tmp_2 = param.projection1(); - nota_v2::SERVICE _tmp_3 = _tmp_2.projection2(); - nota_v2::RESOURCEMANAGER _tmp_4 = _tmp_2.projection1(); - - nota_v2 copiedState = state._copy(); - nota_v2::_ProjectionRead_rm_deregister readState = state._projected_state_for_rm_deregister(); + } else { + _trid_6 = _trid_6_ptr->second; + } - auto _OpCache_with_parameter_rm_deregister_ptr = _OpCache_rm_deregister.find(param); - if(_OpCache_with_parameter_rm_deregister_ptr == _OpCache_rm_deregister.end()) { - copiedState.rm_deregister(_tmp_4, _tmp_3, _tmp_1); - nota_v2::_ProjectionWrite_rm_deregister writeState = copiedState._update_for_rm_deregister(); - std::unordered_map<nota_v2::_ProjectionRead_rm_deregister, nota_v2::_ProjectionWrite_rm_deregister, nota_v2::_ProjectionRead_rm_deregister::Hash, nota_v2::_ProjectionRead_rm_deregister::HashEqual> _OpCache_with_parameter_rm_deregister; - _OpCache_with_parameter_rm_deregister.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_rm_deregister_lock(_ProjectionRead_rm_deregister_mutex); - _OpCache_rm_deregister.insert({param, _OpCache_with_parameter_rm_deregister}); - } + for(const BTuple<BTuple<nota_v2::RESOURCEMANAGER, nota_v2::SERVICE >, nota_v2::INTERCONNECTNODE >& param : _trid_6) { + nota_v2::INTERCONNECTNODE _tmp_1 = param.projection2(); + BTuple<nota_v2::RESOURCEMANAGER, nota_v2::SERVICE > _tmp_2 = param.projection1(); + nota_v2::SERVICE _tmp_3 = _tmp_2.projection2(); + nota_v2::RESOURCEMANAGER _tmp_4 = _tmp_2.projection1(); - } else { - std::unordered_map<nota_v2::_ProjectionRead_rm_deregister, nota_v2::_ProjectionWrite_rm_deregister, nota_v2::_ProjectionRead_rm_deregister::Hash, nota_v2::_ProjectionRead_rm_deregister::HashEqual> _OpCache_with_parameter_rm_deregister = _OpCache_with_parameter_rm_deregister_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_rm_deregister.find(readState); - if(writeState_ptr != _OpCache_with_parameter_rm_deregister.end()) { - nota_v2::_ProjectionWrite_rm_deregister writeState = writeState_ptr->second; - copiedState._apply_update_for_rm_deregister(writeState); - } else { - copiedState.rm_deregister(_tmp_4, _tmp_3, _tmp_1); - nota_v2::_ProjectionWrite_rm_deregister writeState = copiedState._update_for_rm_deregister(); - { - std::unique_lock<std::mutex> _ProjectionRead_rm_deregister_lock(_ProjectionRead_rm_deregister_mutex); - _OpCache_with_parameter_rm_deregister.insert({readState, writeState}); - } - } + nota_v2 copiedState = state._copy(); + nota_v2::_ProjectionRead_rm_deregister readState = state._projected_state_for_rm_deregister(); + + auto _OpCache_with_parameter_rm_deregister_ptr = _OpCache_rm_deregister.find(param); + if(_OpCache_with_parameter_rm_deregister_ptr == _OpCache_rm_deregister.end()) { + copiedState.rm_deregister(_tmp_4, _tmp_3, _tmp_1); + nota_v2::_ProjectionWrite_rm_deregister writeState = copiedState._update_for_rm_deregister(); + std::unordered_map<nota_v2::_ProjectionRead_rm_deregister, nota_v2::_ProjectionWrite_rm_deregister, nota_v2::_ProjectionRead_rm_deregister::Hash, nota_v2::_ProjectionRead_rm_deregister::HashEqual> _OpCache_with_parameter_rm_deregister; + _OpCache_with_parameter_rm_deregister.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_rm_deregister_lock(_ProjectionRead_rm_deregister_mutex); + _OpCache_rm_deregister.insert({param, _OpCache_with_parameter_rm_deregister}); } - copiedState.stateAccessedVia = "rm_deregister"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<BTuple<BTuple<nota_v2::RESOURCEMANAGER, nota_v2::SERVICE >, nota_v2::INTERCONNECTNODE >> _trid_6 = _trid_6_ptr->second; - for(const BTuple<BTuple<nota_v2::RESOURCEMANAGER, nota_v2::SERVICE >, nota_v2::INTERCONNECTNODE >& param : _trid_6) { - nota_v2::INTERCONNECTNODE _tmp_1 = param.projection2(); - BTuple<nota_v2::RESOURCEMANAGER, nota_v2::SERVICE > _tmp_2 = param.projection1(); - nota_v2::SERVICE _tmp_3 = _tmp_2.projection2(); - nota_v2::RESOURCEMANAGER _tmp_4 = _tmp_2.projection1(); - - nota_v2 copiedState = state._copy(); - nota_v2::_ProjectionRead_rm_deregister readState = state._projected_state_for_rm_deregister(); - - auto _OpCache_with_parameter_rm_deregister_ptr = _OpCache_rm_deregister.find(param); - if(_OpCache_with_parameter_rm_deregister_ptr == _OpCache_rm_deregister.end()) { + } else { + std::unordered_map<nota_v2::_ProjectionRead_rm_deregister, nota_v2::_ProjectionWrite_rm_deregister, nota_v2::_ProjectionRead_rm_deregister::Hash, nota_v2::_ProjectionRead_rm_deregister::HashEqual> _OpCache_with_parameter_rm_deregister = _OpCache_with_parameter_rm_deregister_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_rm_deregister.find(readState); + if(writeState_ptr != _OpCache_with_parameter_rm_deregister.end()) { + nota_v2::_ProjectionWrite_rm_deregister writeState = writeState_ptr->second; + copiedState._apply_update_for_rm_deregister(writeState); + } else { copiedState.rm_deregister(_tmp_4, _tmp_3, _tmp_1); nota_v2::_ProjectionWrite_rm_deregister writeState = copiedState._update_for_rm_deregister(); - std::unordered_map<nota_v2::_ProjectionRead_rm_deregister, nota_v2::_ProjectionWrite_rm_deregister, nota_v2::_ProjectionRead_rm_deregister::Hash, nota_v2::_ProjectionRead_rm_deregister::HashEqual> _OpCache_with_parameter_rm_deregister; - _OpCache_with_parameter_rm_deregister.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_rm_deregister_lock(_ProjectionRead_rm_deregister_mutex); - _OpCache_rm_deregister.insert({param, _OpCache_with_parameter_rm_deregister}); - } - - } else { - std::unordered_map<nota_v2::_ProjectionRead_rm_deregister, nota_v2::_ProjectionWrite_rm_deregister, nota_v2::_ProjectionRead_rm_deregister::Hash, nota_v2::_ProjectionRead_rm_deregister::HashEqual> _OpCache_with_parameter_rm_deregister = _OpCache_with_parameter_rm_deregister_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_rm_deregister.find(readState); - if(writeState_ptr != _OpCache_with_parameter_rm_deregister.end()) { - nota_v2::_ProjectionWrite_rm_deregister writeState = writeState_ptr->second; - copiedState._apply_update_for_rm_deregister(writeState); - } else { - copiedState.rm_deregister(_tmp_4, _tmp_3, _tmp_1); - nota_v2::_ProjectionWrite_rm_deregister writeState = copiedState._update_for_rm_deregister(); - { - std::unique_lock<std::mutex> _ProjectionRead_rm_deregister_lock(_ProjectionRead_rm_deregister_mutex); - _OpCache_with_parameter_rm_deregister.insert({readState, writeState}); - } + _OpCache_with_parameter_rm_deregister.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "rm_deregister"; - result.insert(copiedState); + copiedState.stateAccessedVia = "rm_deregister"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } nota_v2::_ProjectionRead__tr_rm_getSid read__tr_rm_getSid_state = state._projected_state_for__tr_rm_getSid(); + BSet<BTuple<nota_v2::RESOURCEMANAGER, nota_v2::SERVICE >> _trid_7; auto _trid_7_ptr = _OpCache_tr_rm_getSid.find(read__tr_rm_getSid_state); if(_trid_7_ptr == _OpCache_tr_rm_getSid.end()) { - BSet<BTuple<nota_v2::RESOURCEMANAGER, nota_v2::SERVICE >> _trid_7 = state._tr_rm_getSid(); + _trid_7 = state._tr_rm_getSid(); { std::unique_lock<std::mutex> _ProjectionRead__tr_rm_getSid_lock(_ProjectionRead__tr_rm_getSid_mutex); _OpCache_tr_rm_getSid.insert({read__tr_rm_getSid_state, _trid_7}); } - for(const BTuple<nota_v2::RESOURCEMANAGER, nota_v2::SERVICE >& param : _trid_7) { - nota_v2::SERVICE _tmp_1 = param.projection2(); - nota_v2::RESOURCEMANAGER _tmp_2 = param.projection1(); - - nota_v2 copiedState = state._copy(); - nota_v2::_ProjectionRead_rm_getSid readState = state._projected_state_for_rm_getSid(); + } else { + _trid_7 = _trid_7_ptr->second; + } - auto _OpCache_with_parameter_rm_getSid_ptr = _OpCache_rm_getSid.find(param); - if(_OpCache_with_parameter_rm_getSid_ptr == _OpCache_rm_getSid.end()) { - copiedState.rm_getSid(_tmp_2, _tmp_1); - nota_v2::_ProjectionWrite_rm_getSid writeState = copiedState._update_for_rm_getSid(); - std::unordered_map<nota_v2::_ProjectionRead_rm_getSid, nota_v2::_ProjectionWrite_rm_getSid, nota_v2::_ProjectionRead_rm_getSid::Hash, nota_v2::_ProjectionRead_rm_getSid::HashEqual> _OpCache_with_parameter_rm_getSid; - _OpCache_with_parameter_rm_getSid.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_rm_getSid_lock(_ProjectionRead_rm_getSid_mutex); - _OpCache_rm_getSid.insert({param, _OpCache_with_parameter_rm_getSid}); - } + for(const BTuple<nota_v2::RESOURCEMANAGER, nota_v2::SERVICE >& param : _trid_7) { + nota_v2::SERVICE _tmp_1 = param.projection2(); + nota_v2::RESOURCEMANAGER _tmp_2 = param.projection1(); - } else { - std::unordered_map<nota_v2::_ProjectionRead_rm_getSid, nota_v2::_ProjectionWrite_rm_getSid, nota_v2::_ProjectionRead_rm_getSid::Hash, nota_v2::_ProjectionRead_rm_getSid::HashEqual> _OpCache_with_parameter_rm_getSid = _OpCache_with_parameter_rm_getSid_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_rm_getSid.find(readState); - if(writeState_ptr != _OpCache_with_parameter_rm_getSid.end()) { - nota_v2::_ProjectionWrite_rm_getSid writeState = writeState_ptr->second; - copiedState._apply_update_for_rm_getSid(writeState); - } else { - copiedState.rm_getSid(_tmp_2, _tmp_1); - nota_v2::_ProjectionWrite_rm_getSid writeState = copiedState._update_for_rm_getSid(); - { - std::unique_lock<std::mutex> _ProjectionRead_rm_getSid_lock(_ProjectionRead_rm_getSid_mutex); - _OpCache_with_parameter_rm_getSid.insert({readState, writeState}); - } - } + nota_v2 copiedState = state._copy(); + nota_v2::_ProjectionRead_rm_getSid readState = state._projected_state_for_rm_getSid(); + + auto _OpCache_with_parameter_rm_getSid_ptr = _OpCache_rm_getSid.find(param); + if(_OpCache_with_parameter_rm_getSid_ptr == _OpCache_rm_getSid.end()) { + copiedState.rm_getSid(_tmp_2, _tmp_1); + nota_v2::_ProjectionWrite_rm_getSid writeState = copiedState._update_for_rm_getSid(); + std::unordered_map<nota_v2::_ProjectionRead_rm_getSid, nota_v2::_ProjectionWrite_rm_getSid, nota_v2::_ProjectionRead_rm_getSid::Hash, nota_v2::_ProjectionRead_rm_getSid::HashEqual> _OpCache_with_parameter_rm_getSid; + _OpCache_with_parameter_rm_getSid.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_rm_getSid_lock(_ProjectionRead_rm_getSid_mutex); + _OpCache_rm_getSid.insert({param, _OpCache_with_parameter_rm_getSid}); } - copiedState.stateAccessedVia = "rm_getSid"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<BTuple<nota_v2::RESOURCEMANAGER, nota_v2::SERVICE >> _trid_7 = _trid_7_ptr->second; - for(const BTuple<nota_v2::RESOURCEMANAGER, nota_v2::SERVICE >& param : _trid_7) { - nota_v2::SERVICE _tmp_1 = param.projection2(); - nota_v2::RESOURCEMANAGER _tmp_2 = param.projection1(); - - nota_v2 copiedState = state._copy(); - nota_v2::_ProjectionRead_rm_getSid readState = state._projected_state_for_rm_getSid(); - - auto _OpCache_with_parameter_rm_getSid_ptr = _OpCache_rm_getSid.find(param); - if(_OpCache_with_parameter_rm_getSid_ptr == _OpCache_rm_getSid.end()) { + } else { + std::unordered_map<nota_v2::_ProjectionRead_rm_getSid, nota_v2::_ProjectionWrite_rm_getSid, nota_v2::_ProjectionRead_rm_getSid::Hash, nota_v2::_ProjectionRead_rm_getSid::HashEqual> _OpCache_with_parameter_rm_getSid = _OpCache_with_parameter_rm_getSid_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_rm_getSid.find(readState); + if(writeState_ptr != _OpCache_with_parameter_rm_getSid.end()) { + nota_v2::_ProjectionWrite_rm_getSid writeState = writeState_ptr->second; + copiedState._apply_update_for_rm_getSid(writeState); + } else { copiedState.rm_getSid(_tmp_2, _tmp_1); nota_v2::_ProjectionWrite_rm_getSid writeState = copiedState._update_for_rm_getSid(); - std::unordered_map<nota_v2::_ProjectionRead_rm_getSid, nota_v2::_ProjectionWrite_rm_getSid, nota_v2::_ProjectionRead_rm_getSid::Hash, nota_v2::_ProjectionRead_rm_getSid::HashEqual> _OpCache_with_parameter_rm_getSid; - _OpCache_with_parameter_rm_getSid.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_rm_getSid_lock(_ProjectionRead_rm_getSid_mutex); - _OpCache_rm_getSid.insert({param, _OpCache_with_parameter_rm_getSid}); - } - - } else { - std::unordered_map<nota_v2::_ProjectionRead_rm_getSid, nota_v2::_ProjectionWrite_rm_getSid, nota_v2::_ProjectionRead_rm_getSid::Hash, nota_v2::_ProjectionRead_rm_getSid::HashEqual> _OpCache_with_parameter_rm_getSid = _OpCache_with_parameter_rm_getSid_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_rm_getSid.find(readState); - if(writeState_ptr != _OpCache_with_parameter_rm_getSid.end()) { - nota_v2::_ProjectionWrite_rm_getSid writeState = writeState_ptr->second; - copiedState._apply_update_for_rm_getSid(writeState); - } else { - copiedState.rm_getSid(_tmp_2, _tmp_1); - nota_v2::_ProjectionWrite_rm_getSid writeState = copiedState._update_for_rm_getSid(); - { - std::unique_lock<std::mutex> _ProjectionRead_rm_getSid_lock(_ProjectionRead_rm_getSid_mutex); - _OpCache_with_parameter_rm_getSid.insert({readState, writeState}); - } + _OpCache_with_parameter_rm_getSid.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "rm_getSid"; - result.insert(copiedState); + copiedState.stateAccessedVia = "rm_getSid"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } nota_v2::_ProjectionRead__tr_rm_getSid_Not_Found read__tr_rm_getSid_Not_Found_state = state._projected_state_for__tr_rm_getSid_Not_Found(); + BSet<BTuple<nota_v2::RESOURCEMANAGER, nota_v2::SERVICE >> _trid_8; auto _trid_8_ptr = _OpCache_tr_rm_getSid_Not_Found.find(read__tr_rm_getSid_Not_Found_state); if(_trid_8_ptr == _OpCache_tr_rm_getSid_Not_Found.end()) { - BSet<BTuple<nota_v2::RESOURCEMANAGER, nota_v2::SERVICE >> _trid_8 = state._tr_rm_getSid_Not_Found(); + _trid_8 = state._tr_rm_getSid_Not_Found(); { std::unique_lock<std::mutex> _ProjectionRead__tr_rm_getSid_Not_Found_lock(_ProjectionRead__tr_rm_getSid_Not_Found_mutex); _OpCache_tr_rm_getSid_Not_Found.insert({read__tr_rm_getSid_Not_Found_state, _trid_8}); } - for(const BTuple<nota_v2::RESOURCEMANAGER, nota_v2::SERVICE >& param : _trid_8) { - nota_v2::SERVICE _tmp_1 = param.projection2(); - nota_v2::RESOURCEMANAGER _tmp_2 = param.projection1(); - - nota_v2 copiedState = state._copy(); - nota_v2::_ProjectionRead_rm_getSid_Not_Found readState = state._projected_state_for_rm_getSid_Not_Found(); + } else { + _trid_8 = _trid_8_ptr->second; + } - auto _OpCache_with_parameter_rm_getSid_Not_Found_ptr = _OpCache_rm_getSid_Not_Found.find(param); - if(_OpCache_with_parameter_rm_getSid_Not_Found_ptr == _OpCache_rm_getSid_Not_Found.end()) { - copiedState.rm_getSid_Not_Found(_tmp_2, _tmp_1); - nota_v2::_ProjectionWrite_rm_getSid_Not_Found writeState = copiedState._update_for_rm_getSid_Not_Found(); - std::unordered_map<nota_v2::_ProjectionRead_rm_getSid_Not_Found, nota_v2::_ProjectionWrite_rm_getSid_Not_Found, nota_v2::_ProjectionRead_rm_getSid_Not_Found::Hash, nota_v2::_ProjectionRead_rm_getSid_Not_Found::HashEqual> _OpCache_with_parameter_rm_getSid_Not_Found; - _OpCache_with_parameter_rm_getSid_Not_Found.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_rm_getSid_Not_Found_lock(_ProjectionRead_rm_getSid_Not_Found_mutex); - _OpCache_rm_getSid_Not_Found.insert({param, _OpCache_with_parameter_rm_getSid_Not_Found}); - } + for(const BTuple<nota_v2::RESOURCEMANAGER, nota_v2::SERVICE >& param : _trid_8) { + nota_v2::SERVICE _tmp_1 = param.projection2(); + nota_v2::RESOURCEMANAGER _tmp_2 = param.projection1(); - } else { - std::unordered_map<nota_v2::_ProjectionRead_rm_getSid_Not_Found, nota_v2::_ProjectionWrite_rm_getSid_Not_Found, nota_v2::_ProjectionRead_rm_getSid_Not_Found::Hash, nota_v2::_ProjectionRead_rm_getSid_Not_Found::HashEqual> _OpCache_with_parameter_rm_getSid_Not_Found = _OpCache_with_parameter_rm_getSid_Not_Found_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_rm_getSid_Not_Found.find(readState); - if(writeState_ptr != _OpCache_with_parameter_rm_getSid_Not_Found.end()) { - nota_v2::_ProjectionWrite_rm_getSid_Not_Found writeState = writeState_ptr->second; - copiedState._apply_update_for_rm_getSid_Not_Found(writeState); - } else { - copiedState.rm_getSid_Not_Found(_tmp_2, _tmp_1); - nota_v2::_ProjectionWrite_rm_getSid_Not_Found writeState = copiedState._update_for_rm_getSid_Not_Found(); - { - std::unique_lock<std::mutex> _ProjectionRead_rm_getSid_Not_Found_lock(_ProjectionRead_rm_getSid_Not_Found_mutex); - _OpCache_with_parameter_rm_getSid_Not_Found.insert({readState, writeState}); - } - } + nota_v2 copiedState = state._copy(); + nota_v2::_ProjectionRead_rm_getSid_Not_Found readState = state._projected_state_for_rm_getSid_Not_Found(); + + auto _OpCache_with_parameter_rm_getSid_Not_Found_ptr = _OpCache_rm_getSid_Not_Found.find(param); + if(_OpCache_with_parameter_rm_getSid_Not_Found_ptr == _OpCache_rm_getSid_Not_Found.end()) { + copiedState.rm_getSid_Not_Found(_tmp_2, _tmp_1); + nota_v2::_ProjectionWrite_rm_getSid_Not_Found writeState = copiedState._update_for_rm_getSid_Not_Found(); + std::unordered_map<nota_v2::_ProjectionRead_rm_getSid_Not_Found, nota_v2::_ProjectionWrite_rm_getSid_Not_Found, nota_v2::_ProjectionRead_rm_getSid_Not_Found::Hash, nota_v2::_ProjectionRead_rm_getSid_Not_Found::HashEqual> _OpCache_with_parameter_rm_getSid_Not_Found; + _OpCache_with_parameter_rm_getSid_Not_Found.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_rm_getSid_Not_Found_lock(_ProjectionRead_rm_getSid_Not_Found_mutex); + _OpCache_rm_getSid_Not_Found.insert({param, _OpCache_with_parameter_rm_getSid_Not_Found}); } - copiedState.stateAccessedVia = "rm_getSid_Not_Found"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<BTuple<nota_v2::RESOURCEMANAGER, nota_v2::SERVICE >> _trid_8 = _trid_8_ptr->second; - for(const BTuple<nota_v2::RESOURCEMANAGER, nota_v2::SERVICE >& param : _trid_8) { - nota_v2::SERVICE _tmp_1 = param.projection2(); - nota_v2::RESOURCEMANAGER _tmp_2 = param.projection1(); - - nota_v2 copiedState = state._copy(); - nota_v2::_ProjectionRead_rm_getSid_Not_Found readState = state._projected_state_for_rm_getSid_Not_Found(); - - auto _OpCache_with_parameter_rm_getSid_Not_Found_ptr = _OpCache_rm_getSid_Not_Found.find(param); - if(_OpCache_with_parameter_rm_getSid_Not_Found_ptr == _OpCache_rm_getSid_Not_Found.end()) { + } else { + std::unordered_map<nota_v2::_ProjectionRead_rm_getSid_Not_Found, nota_v2::_ProjectionWrite_rm_getSid_Not_Found, nota_v2::_ProjectionRead_rm_getSid_Not_Found::Hash, nota_v2::_ProjectionRead_rm_getSid_Not_Found::HashEqual> _OpCache_with_parameter_rm_getSid_Not_Found = _OpCache_with_parameter_rm_getSid_Not_Found_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_rm_getSid_Not_Found.find(readState); + if(writeState_ptr != _OpCache_with_parameter_rm_getSid_Not_Found.end()) { + nota_v2::_ProjectionWrite_rm_getSid_Not_Found writeState = writeState_ptr->second; + copiedState._apply_update_for_rm_getSid_Not_Found(writeState); + } else { copiedState.rm_getSid_Not_Found(_tmp_2, _tmp_1); nota_v2::_ProjectionWrite_rm_getSid_Not_Found writeState = copiedState._update_for_rm_getSid_Not_Found(); - std::unordered_map<nota_v2::_ProjectionRead_rm_getSid_Not_Found, nota_v2::_ProjectionWrite_rm_getSid_Not_Found, nota_v2::_ProjectionRead_rm_getSid_Not_Found::Hash, nota_v2::_ProjectionRead_rm_getSid_Not_Found::HashEqual> _OpCache_with_parameter_rm_getSid_Not_Found; - _OpCache_with_parameter_rm_getSid_Not_Found.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_rm_getSid_Not_Found_lock(_ProjectionRead_rm_getSid_Not_Found_mutex); - _OpCache_rm_getSid_Not_Found.insert({param, _OpCache_with_parameter_rm_getSid_Not_Found}); - } - - } else { - std::unordered_map<nota_v2::_ProjectionRead_rm_getSid_Not_Found, nota_v2::_ProjectionWrite_rm_getSid_Not_Found, nota_v2::_ProjectionRead_rm_getSid_Not_Found::Hash, nota_v2::_ProjectionRead_rm_getSid_Not_Found::HashEqual> _OpCache_with_parameter_rm_getSid_Not_Found = _OpCache_with_parameter_rm_getSid_Not_Found_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_rm_getSid_Not_Found.find(readState); - if(writeState_ptr != _OpCache_with_parameter_rm_getSid_Not_Found.end()) { - nota_v2::_ProjectionWrite_rm_getSid_Not_Found writeState = writeState_ptr->second; - copiedState._apply_update_for_rm_getSid_Not_Found(writeState); - } else { - copiedState.rm_getSid_Not_Found(_tmp_2, _tmp_1); - nota_v2::_ProjectionWrite_rm_getSid_Not_Found writeState = copiedState._update_for_rm_getSid_Not_Found(); - { - std::unique_lock<std::mutex> _ProjectionRead_rm_getSid_Not_Found_lock(_ProjectionRead_rm_getSid_Not_Found_mutex); - _OpCache_with_parameter_rm_getSid_Not_Found.insert({readState, writeState}); - } + _OpCache_with_parameter_rm_getSid_Not_Found.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "rm_getSid_Not_Found"; - result.insert(copiedState); + copiedState.stateAccessedVia = "rm_getSid_Not_Found"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } nota_v2::_ProjectionRead__tr_in_announceResourceManager read__tr_in_announceResourceManager_state = state._projected_state_for__tr_in_announceResourceManager(); + BSet<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::RESOURCEMANAGER >> _trid_9; auto _trid_9_ptr = _OpCache_tr_in_announceResourceManager.find(read__tr_in_announceResourceManager_state); if(_trid_9_ptr == _OpCache_tr_in_announceResourceManager.end()) { - BSet<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::RESOURCEMANAGER >> _trid_9 = state._tr_in_announceResourceManager(); + _trid_9 = state._tr_in_announceResourceManager(); { std::unique_lock<std::mutex> _ProjectionRead__tr_in_announceResourceManager_lock(_ProjectionRead__tr_in_announceResourceManager_mutex); _OpCache_tr_in_announceResourceManager.insert({read__tr_in_announceResourceManager_state, _trid_9}); } - for(const BTuple<nota_v2::INTERCONNECTNODE, nota_v2::RESOURCEMANAGER >& param : _trid_9) { - nota_v2::RESOURCEMANAGER _tmp_1 = param.projection2(); - nota_v2::INTERCONNECTNODE _tmp_2 = param.projection1(); - - nota_v2 copiedState = state._copy(); - nota_v2::_ProjectionRead_in_announceResourceManager readState = state._projected_state_for_in_announceResourceManager(); + } else { + _trid_9 = _trid_9_ptr->second; + } - auto _OpCache_with_parameter_in_announceResourceManager_ptr = _OpCache_in_announceResourceManager.find(param); - if(_OpCache_with_parameter_in_announceResourceManager_ptr == _OpCache_in_announceResourceManager.end()) { - copiedState.in_announceResourceManager(_tmp_2, _tmp_1); - nota_v2::_ProjectionWrite_in_announceResourceManager writeState = copiedState._update_for_in_announceResourceManager(); - std::unordered_map<nota_v2::_ProjectionRead_in_announceResourceManager, nota_v2::_ProjectionWrite_in_announceResourceManager, nota_v2::_ProjectionRead_in_announceResourceManager::Hash, nota_v2::_ProjectionRead_in_announceResourceManager::HashEqual> _OpCache_with_parameter_in_announceResourceManager; - _OpCache_with_parameter_in_announceResourceManager.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_in_announceResourceManager_lock(_ProjectionRead_in_announceResourceManager_mutex); - _OpCache_in_announceResourceManager.insert({param, _OpCache_with_parameter_in_announceResourceManager}); - } + for(const BTuple<nota_v2::INTERCONNECTNODE, nota_v2::RESOURCEMANAGER >& param : _trid_9) { + nota_v2::RESOURCEMANAGER _tmp_1 = param.projection2(); + nota_v2::INTERCONNECTNODE _tmp_2 = param.projection1(); - } else { - std::unordered_map<nota_v2::_ProjectionRead_in_announceResourceManager, nota_v2::_ProjectionWrite_in_announceResourceManager, nota_v2::_ProjectionRead_in_announceResourceManager::Hash, nota_v2::_ProjectionRead_in_announceResourceManager::HashEqual> _OpCache_with_parameter_in_announceResourceManager = _OpCache_with_parameter_in_announceResourceManager_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_in_announceResourceManager.find(readState); - if(writeState_ptr != _OpCache_with_parameter_in_announceResourceManager.end()) { - nota_v2::_ProjectionWrite_in_announceResourceManager writeState = writeState_ptr->second; - copiedState._apply_update_for_in_announceResourceManager(writeState); - } else { - copiedState.in_announceResourceManager(_tmp_2, _tmp_1); - nota_v2::_ProjectionWrite_in_announceResourceManager writeState = copiedState._update_for_in_announceResourceManager(); - { - std::unique_lock<std::mutex> _ProjectionRead_in_announceResourceManager_lock(_ProjectionRead_in_announceResourceManager_mutex); - _OpCache_with_parameter_in_announceResourceManager.insert({readState, writeState}); - } - } + nota_v2 copiedState = state._copy(); + nota_v2::_ProjectionRead_in_announceResourceManager readState = state._projected_state_for_in_announceResourceManager(); + + auto _OpCache_with_parameter_in_announceResourceManager_ptr = _OpCache_in_announceResourceManager.find(param); + if(_OpCache_with_parameter_in_announceResourceManager_ptr == _OpCache_in_announceResourceManager.end()) { + copiedState.in_announceResourceManager(_tmp_2, _tmp_1); + nota_v2::_ProjectionWrite_in_announceResourceManager writeState = copiedState._update_for_in_announceResourceManager(); + std::unordered_map<nota_v2::_ProjectionRead_in_announceResourceManager, nota_v2::_ProjectionWrite_in_announceResourceManager, nota_v2::_ProjectionRead_in_announceResourceManager::Hash, nota_v2::_ProjectionRead_in_announceResourceManager::HashEqual> _OpCache_with_parameter_in_announceResourceManager; + _OpCache_with_parameter_in_announceResourceManager.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_in_announceResourceManager_lock(_ProjectionRead_in_announceResourceManager_mutex); + _OpCache_in_announceResourceManager.insert({param, _OpCache_with_parameter_in_announceResourceManager}); } - copiedState.stateAccessedVia = "in_announceResourceManager"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::RESOURCEMANAGER >> _trid_9 = _trid_9_ptr->second; - for(const BTuple<nota_v2::INTERCONNECTNODE, nota_v2::RESOURCEMANAGER >& param : _trid_9) { - nota_v2::RESOURCEMANAGER _tmp_1 = param.projection2(); - nota_v2::INTERCONNECTNODE _tmp_2 = param.projection1(); - - nota_v2 copiedState = state._copy(); - nota_v2::_ProjectionRead_in_announceResourceManager readState = state._projected_state_for_in_announceResourceManager(); - - auto _OpCache_with_parameter_in_announceResourceManager_ptr = _OpCache_in_announceResourceManager.find(param); - if(_OpCache_with_parameter_in_announceResourceManager_ptr == _OpCache_in_announceResourceManager.end()) { + } else { + std::unordered_map<nota_v2::_ProjectionRead_in_announceResourceManager, nota_v2::_ProjectionWrite_in_announceResourceManager, nota_v2::_ProjectionRead_in_announceResourceManager::Hash, nota_v2::_ProjectionRead_in_announceResourceManager::HashEqual> _OpCache_with_parameter_in_announceResourceManager = _OpCache_with_parameter_in_announceResourceManager_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_in_announceResourceManager.find(readState); + if(writeState_ptr != _OpCache_with_parameter_in_announceResourceManager.end()) { + nota_v2::_ProjectionWrite_in_announceResourceManager writeState = writeState_ptr->second; + copiedState._apply_update_for_in_announceResourceManager(writeState); + } else { copiedState.in_announceResourceManager(_tmp_2, _tmp_1); nota_v2::_ProjectionWrite_in_announceResourceManager writeState = copiedState._update_for_in_announceResourceManager(); - std::unordered_map<nota_v2::_ProjectionRead_in_announceResourceManager, nota_v2::_ProjectionWrite_in_announceResourceManager, nota_v2::_ProjectionRead_in_announceResourceManager::Hash, nota_v2::_ProjectionRead_in_announceResourceManager::HashEqual> _OpCache_with_parameter_in_announceResourceManager; - _OpCache_with_parameter_in_announceResourceManager.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_in_announceResourceManager_lock(_ProjectionRead_in_announceResourceManager_mutex); - _OpCache_in_announceResourceManager.insert({param, _OpCache_with_parameter_in_announceResourceManager}); - } - - } else { - std::unordered_map<nota_v2::_ProjectionRead_in_announceResourceManager, nota_v2::_ProjectionWrite_in_announceResourceManager, nota_v2::_ProjectionRead_in_announceResourceManager::Hash, nota_v2::_ProjectionRead_in_announceResourceManager::HashEqual> _OpCache_with_parameter_in_announceResourceManager = _OpCache_with_parameter_in_announceResourceManager_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_in_announceResourceManager.find(readState); - if(writeState_ptr != _OpCache_with_parameter_in_announceResourceManager.end()) { - nota_v2::_ProjectionWrite_in_announceResourceManager writeState = writeState_ptr->second; - copiedState._apply_update_for_in_announceResourceManager(writeState); - } else { - copiedState.in_announceResourceManager(_tmp_2, _tmp_1); - nota_v2::_ProjectionWrite_in_announceResourceManager writeState = copiedState._update_for_in_announceResourceManager(); - { - std::unique_lock<std::mutex> _ProjectionRead_in_announceResourceManager_lock(_ProjectionRead_in_announceResourceManager_mutex); - _OpCache_with_parameter_in_announceResourceManager.insert({readState, writeState}); - } + _OpCache_with_parameter_in_announceResourceManager.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "in_announceResourceManager"; - result.insert(copiedState); + copiedState.stateAccessedVia = "in_announceResourceManager"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } nota_v2::_ProjectionRead__tr_in_register_success read__tr_in_register_success_state = state._projected_state_for__tr_in_register_success(); + BSet<BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::SERVICE >, nota_v2::SID >> _trid_10; auto _trid_10_ptr = _OpCache_tr_in_register_success.find(read__tr_in_register_success_state); if(_trid_10_ptr == _OpCache_tr_in_register_success.end()) { - BSet<BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::SERVICE >, nota_v2::SID >> _trid_10 = state._tr_in_register_success(); + _trid_10 = state._tr_in_register_success(); { std::unique_lock<std::mutex> _ProjectionRead__tr_in_register_success_lock(_ProjectionRead__tr_in_register_success_mutex); _OpCache_tr_in_register_success.insert({read__tr_in_register_success_state, _trid_10}); } - for(const BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::SERVICE >, nota_v2::SID >& param : _trid_10) { - nota_v2::SID _tmp_1 = param.projection2(); - BTuple<nota_v2::INTERCONNECTNODE, nota_v2::SERVICE > _tmp_2 = param.projection1(); - nota_v2::SERVICE _tmp_3 = _tmp_2.projection2(); - nota_v2::INTERCONNECTNODE _tmp_4 = _tmp_2.projection1(); - - nota_v2 copiedState = state._copy(); - nota_v2::_ProjectionRead_in_register_success readState = state._projected_state_for_in_register_success(); + } else { + _trid_10 = _trid_10_ptr->second; + } - auto _OpCache_with_parameter_in_register_success_ptr = _OpCache_in_register_success.find(param); - if(_OpCache_with_parameter_in_register_success_ptr == _OpCache_in_register_success.end()) { - copiedState.in_register_success(_tmp_4, _tmp_3, _tmp_1); - nota_v2::_ProjectionWrite_in_register_success writeState = copiedState._update_for_in_register_success(); - std::unordered_map<nota_v2::_ProjectionRead_in_register_success, nota_v2::_ProjectionWrite_in_register_success, nota_v2::_ProjectionRead_in_register_success::Hash, nota_v2::_ProjectionRead_in_register_success::HashEqual> _OpCache_with_parameter_in_register_success; - _OpCache_with_parameter_in_register_success.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_in_register_success_lock(_ProjectionRead_in_register_success_mutex); - _OpCache_in_register_success.insert({param, _OpCache_with_parameter_in_register_success}); - } + for(const BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::SERVICE >, nota_v2::SID >& param : _trid_10) { + nota_v2::SID _tmp_1 = param.projection2(); + BTuple<nota_v2::INTERCONNECTNODE, nota_v2::SERVICE > _tmp_2 = param.projection1(); + nota_v2::SERVICE _tmp_3 = _tmp_2.projection2(); + nota_v2::INTERCONNECTNODE _tmp_4 = _tmp_2.projection1(); - } else { - std::unordered_map<nota_v2::_ProjectionRead_in_register_success, nota_v2::_ProjectionWrite_in_register_success, nota_v2::_ProjectionRead_in_register_success::Hash, nota_v2::_ProjectionRead_in_register_success::HashEqual> _OpCache_with_parameter_in_register_success = _OpCache_with_parameter_in_register_success_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_in_register_success.find(readState); - if(writeState_ptr != _OpCache_with_parameter_in_register_success.end()) { - nota_v2::_ProjectionWrite_in_register_success writeState = writeState_ptr->second; - copiedState._apply_update_for_in_register_success(writeState); - } else { - copiedState.in_register_success(_tmp_4, _tmp_3, _tmp_1); - nota_v2::_ProjectionWrite_in_register_success writeState = copiedState._update_for_in_register_success(); - { - std::unique_lock<std::mutex> _ProjectionRead_in_register_success_lock(_ProjectionRead_in_register_success_mutex); - _OpCache_with_parameter_in_register_success.insert({readState, writeState}); - } - } + nota_v2 copiedState = state._copy(); + nota_v2::_ProjectionRead_in_register_success readState = state._projected_state_for_in_register_success(); + + auto _OpCache_with_parameter_in_register_success_ptr = _OpCache_in_register_success.find(param); + if(_OpCache_with_parameter_in_register_success_ptr == _OpCache_in_register_success.end()) { + copiedState.in_register_success(_tmp_4, _tmp_3, _tmp_1); + nota_v2::_ProjectionWrite_in_register_success writeState = copiedState._update_for_in_register_success(); + std::unordered_map<nota_v2::_ProjectionRead_in_register_success, nota_v2::_ProjectionWrite_in_register_success, nota_v2::_ProjectionRead_in_register_success::Hash, nota_v2::_ProjectionRead_in_register_success::HashEqual> _OpCache_with_parameter_in_register_success; + _OpCache_with_parameter_in_register_success.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_in_register_success_lock(_ProjectionRead_in_register_success_mutex); + _OpCache_in_register_success.insert({param, _OpCache_with_parameter_in_register_success}); } - copiedState.stateAccessedVia = "in_register_success"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::SERVICE >, nota_v2::SID >> _trid_10 = _trid_10_ptr->second; - for(const BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::SERVICE >, nota_v2::SID >& param : _trid_10) { - nota_v2::SID _tmp_1 = param.projection2(); - BTuple<nota_v2::INTERCONNECTNODE, nota_v2::SERVICE > _tmp_2 = param.projection1(); - nota_v2::SERVICE _tmp_3 = _tmp_2.projection2(); - nota_v2::INTERCONNECTNODE _tmp_4 = _tmp_2.projection1(); - - nota_v2 copiedState = state._copy(); - nota_v2::_ProjectionRead_in_register_success readState = state._projected_state_for_in_register_success(); - - auto _OpCache_with_parameter_in_register_success_ptr = _OpCache_in_register_success.find(param); - if(_OpCache_with_parameter_in_register_success_ptr == _OpCache_in_register_success.end()) { + } else { + std::unordered_map<nota_v2::_ProjectionRead_in_register_success, nota_v2::_ProjectionWrite_in_register_success, nota_v2::_ProjectionRead_in_register_success::Hash, nota_v2::_ProjectionRead_in_register_success::HashEqual> _OpCache_with_parameter_in_register_success = _OpCache_with_parameter_in_register_success_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_in_register_success.find(readState); + if(writeState_ptr != _OpCache_with_parameter_in_register_success.end()) { + nota_v2::_ProjectionWrite_in_register_success writeState = writeState_ptr->second; + copiedState._apply_update_for_in_register_success(writeState); + } else { copiedState.in_register_success(_tmp_4, _tmp_3, _tmp_1); nota_v2::_ProjectionWrite_in_register_success writeState = copiedState._update_for_in_register_success(); - std::unordered_map<nota_v2::_ProjectionRead_in_register_success, nota_v2::_ProjectionWrite_in_register_success, nota_v2::_ProjectionRead_in_register_success::Hash, nota_v2::_ProjectionRead_in_register_success::HashEqual> _OpCache_with_parameter_in_register_success; - _OpCache_with_parameter_in_register_success.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_in_register_success_lock(_ProjectionRead_in_register_success_mutex); - _OpCache_in_register_success.insert({param, _OpCache_with_parameter_in_register_success}); - } - - } else { - std::unordered_map<nota_v2::_ProjectionRead_in_register_success, nota_v2::_ProjectionWrite_in_register_success, nota_v2::_ProjectionRead_in_register_success::Hash, nota_v2::_ProjectionRead_in_register_success::HashEqual> _OpCache_with_parameter_in_register_success = _OpCache_with_parameter_in_register_success_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_in_register_success.find(readState); - if(writeState_ptr != _OpCache_with_parameter_in_register_success.end()) { - nota_v2::_ProjectionWrite_in_register_success writeState = writeState_ptr->second; - copiedState._apply_update_for_in_register_success(writeState); - } else { - copiedState.in_register_success(_tmp_4, _tmp_3, _tmp_1); - nota_v2::_ProjectionWrite_in_register_success writeState = copiedState._update_for_in_register_success(); - { - std::unique_lock<std::mutex> _ProjectionRead_in_register_success_lock(_ProjectionRead_in_register_success_mutex); - _OpCache_with_parameter_in_register_success.insert({readState, writeState}); - } + _OpCache_with_parameter_in_register_success.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "in_register_success"; - result.insert(copiedState); + copiedState.stateAccessedVia = "in_register_success"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } nota_v2::_ProjectionRead__tr_in_register_failed read__tr_in_register_failed_state = state._projected_state_for__tr_in_register_failed(); + BSet<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::SERVICE >> _trid_11; auto _trid_11_ptr = _OpCache_tr_in_register_failed.find(read__tr_in_register_failed_state); if(_trid_11_ptr == _OpCache_tr_in_register_failed.end()) { - BSet<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::SERVICE >> _trid_11 = state._tr_in_register_failed(); + _trid_11 = state._tr_in_register_failed(); { std::unique_lock<std::mutex> _ProjectionRead__tr_in_register_failed_lock(_ProjectionRead__tr_in_register_failed_mutex); _OpCache_tr_in_register_failed.insert({read__tr_in_register_failed_state, _trid_11}); } - for(const BTuple<nota_v2::INTERCONNECTNODE, nota_v2::SERVICE >& param : _trid_11) { - nota_v2::SERVICE _tmp_1 = param.projection2(); - nota_v2::INTERCONNECTNODE _tmp_2 = param.projection1(); - - nota_v2 copiedState = state._copy(); - nota_v2::_ProjectionRead_in_register_failed readState = state._projected_state_for_in_register_failed(); + } else { + _trid_11 = _trid_11_ptr->second; + } - auto _OpCache_with_parameter_in_register_failed_ptr = _OpCache_in_register_failed.find(param); - if(_OpCache_with_parameter_in_register_failed_ptr == _OpCache_in_register_failed.end()) { - copiedState.in_register_failed(_tmp_2, _tmp_1); - nota_v2::_ProjectionWrite_in_register_failed writeState = copiedState._update_for_in_register_failed(); - std::unordered_map<nota_v2::_ProjectionRead_in_register_failed, nota_v2::_ProjectionWrite_in_register_failed, nota_v2::_ProjectionRead_in_register_failed::Hash, nota_v2::_ProjectionRead_in_register_failed::HashEqual> _OpCache_with_parameter_in_register_failed; - _OpCache_with_parameter_in_register_failed.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_in_register_failed_lock(_ProjectionRead_in_register_failed_mutex); - _OpCache_in_register_failed.insert({param, _OpCache_with_parameter_in_register_failed}); - } + for(const BTuple<nota_v2::INTERCONNECTNODE, nota_v2::SERVICE >& param : _trid_11) { + nota_v2::SERVICE _tmp_1 = param.projection2(); + nota_v2::INTERCONNECTNODE _tmp_2 = param.projection1(); - } else { - std::unordered_map<nota_v2::_ProjectionRead_in_register_failed, nota_v2::_ProjectionWrite_in_register_failed, nota_v2::_ProjectionRead_in_register_failed::Hash, nota_v2::_ProjectionRead_in_register_failed::HashEqual> _OpCache_with_parameter_in_register_failed = _OpCache_with_parameter_in_register_failed_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_in_register_failed.find(readState); - if(writeState_ptr != _OpCache_with_parameter_in_register_failed.end()) { - nota_v2::_ProjectionWrite_in_register_failed writeState = writeState_ptr->second; - copiedState._apply_update_for_in_register_failed(writeState); - } else { - copiedState.in_register_failed(_tmp_2, _tmp_1); - nota_v2::_ProjectionWrite_in_register_failed writeState = copiedState._update_for_in_register_failed(); - { - std::unique_lock<std::mutex> _ProjectionRead_in_register_failed_lock(_ProjectionRead_in_register_failed_mutex); - _OpCache_with_parameter_in_register_failed.insert({readState, writeState}); - } - } + nota_v2 copiedState = state._copy(); + nota_v2::_ProjectionRead_in_register_failed readState = state._projected_state_for_in_register_failed(); + + auto _OpCache_with_parameter_in_register_failed_ptr = _OpCache_in_register_failed.find(param); + if(_OpCache_with_parameter_in_register_failed_ptr == _OpCache_in_register_failed.end()) { + copiedState.in_register_failed(_tmp_2, _tmp_1); + nota_v2::_ProjectionWrite_in_register_failed writeState = copiedState._update_for_in_register_failed(); + std::unordered_map<nota_v2::_ProjectionRead_in_register_failed, nota_v2::_ProjectionWrite_in_register_failed, nota_v2::_ProjectionRead_in_register_failed::Hash, nota_v2::_ProjectionRead_in_register_failed::HashEqual> _OpCache_with_parameter_in_register_failed; + _OpCache_with_parameter_in_register_failed.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_in_register_failed_lock(_ProjectionRead_in_register_failed_mutex); + _OpCache_in_register_failed.insert({param, _OpCache_with_parameter_in_register_failed}); } - copiedState.stateAccessedVia = "in_register_failed"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::SERVICE >> _trid_11 = _trid_11_ptr->second; - for(const BTuple<nota_v2::INTERCONNECTNODE, nota_v2::SERVICE >& param : _trid_11) { - nota_v2::SERVICE _tmp_1 = param.projection2(); - nota_v2::INTERCONNECTNODE _tmp_2 = param.projection1(); - - nota_v2 copiedState = state._copy(); - nota_v2::_ProjectionRead_in_register_failed readState = state._projected_state_for_in_register_failed(); - - auto _OpCache_with_parameter_in_register_failed_ptr = _OpCache_in_register_failed.find(param); - if(_OpCache_with_parameter_in_register_failed_ptr == _OpCache_in_register_failed.end()) { + } else { + std::unordered_map<nota_v2::_ProjectionRead_in_register_failed, nota_v2::_ProjectionWrite_in_register_failed, nota_v2::_ProjectionRead_in_register_failed::Hash, nota_v2::_ProjectionRead_in_register_failed::HashEqual> _OpCache_with_parameter_in_register_failed = _OpCache_with_parameter_in_register_failed_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_in_register_failed.find(readState); + if(writeState_ptr != _OpCache_with_parameter_in_register_failed.end()) { + nota_v2::_ProjectionWrite_in_register_failed writeState = writeState_ptr->second; + copiedState._apply_update_for_in_register_failed(writeState); + } else { copiedState.in_register_failed(_tmp_2, _tmp_1); nota_v2::_ProjectionWrite_in_register_failed writeState = copiedState._update_for_in_register_failed(); - std::unordered_map<nota_v2::_ProjectionRead_in_register_failed, nota_v2::_ProjectionWrite_in_register_failed, nota_v2::_ProjectionRead_in_register_failed::Hash, nota_v2::_ProjectionRead_in_register_failed::HashEqual> _OpCache_with_parameter_in_register_failed; - _OpCache_with_parameter_in_register_failed.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_in_register_failed_lock(_ProjectionRead_in_register_failed_mutex); - _OpCache_in_register_failed.insert({param, _OpCache_with_parameter_in_register_failed}); - } - - } else { - std::unordered_map<nota_v2::_ProjectionRead_in_register_failed, nota_v2::_ProjectionWrite_in_register_failed, nota_v2::_ProjectionRead_in_register_failed::Hash, nota_v2::_ProjectionRead_in_register_failed::HashEqual> _OpCache_with_parameter_in_register_failed = _OpCache_with_parameter_in_register_failed_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_in_register_failed.find(readState); - if(writeState_ptr != _OpCache_with_parameter_in_register_failed.end()) { - nota_v2::_ProjectionWrite_in_register_failed writeState = writeState_ptr->second; - copiedState._apply_update_for_in_register_failed(writeState); - } else { - copiedState.in_register_failed(_tmp_2, _tmp_1); - nota_v2::_ProjectionWrite_in_register_failed writeState = copiedState._update_for_in_register_failed(); - { - std::unique_lock<std::mutex> _ProjectionRead_in_register_failed_lock(_ProjectionRead_in_register_failed_mutex); - _OpCache_with_parameter_in_register_failed.insert({readState, writeState}); - } + _OpCache_with_parameter_in_register_failed.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "in_register_failed"; - result.insert(copiedState); + copiedState.stateAccessedVia = "in_register_failed"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } nota_v2::_ProjectionRead__tr_in_requestTargetSocket_Granted read__tr_in_requestTargetSocket_Granted_state = state._projected_state_for__tr_in_requestTargetSocket_Granted(); + BSet<BTuple<BTuple<BTuple<BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::INTERCONNECTNODE >, nota_v2::SOCKET >, nota_v2::SID >, nota_v2::SID >, nota_v2::SOCKET >> _trid_12; auto _trid_12_ptr = _OpCache_tr_in_requestTargetSocket_Granted.find(read__tr_in_requestTargetSocket_Granted_state); if(_trid_12_ptr == _OpCache_tr_in_requestTargetSocket_Granted.end()) { - BSet<BTuple<BTuple<BTuple<BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::INTERCONNECTNODE >, nota_v2::SOCKET >, nota_v2::SID >, nota_v2::SID >, nota_v2::SOCKET >> _trid_12 = state._tr_in_requestTargetSocket_Granted(); + _trid_12 = state._tr_in_requestTargetSocket_Granted(); { std::unique_lock<std::mutex> _ProjectionRead__tr_in_requestTargetSocket_Granted_lock(_ProjectionRead__tr_in_requestTargetSocket_Granted_mutex); _OpCache_tr_in_requestTargetSocket_Granted.insert({read__tr_in_requestTargetSocket_Granted_state, _trid_12}); } - for(const BTuple<BTuple<BTuple<BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::INTERCONNECTNODE >, nota_v2::SOCKET >, nota_v2::SID >, nota_v2::SID >, nota_v2::SOCKET >& param : _trid_12) { - nota_v2::SOCKET _tmp_1 = param.projection2(); - BTuple<BTuple<BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::INTERCONNECTNODE >, nota_v2::SOCKET >, nota_v2::SID >, nota_v2::SID > _tmp_2 = param.projection1(); - nota_v2::SID _tmp_3 = _tmp_2.projection2(); - BTuple<BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::INTERCONNECTNODE >, nota_v2::SOCKET >, nota_v2::SID > _tmp_4 = _tmp_2.projection1(); - nota_v2::SID _tmp_5 = _tmp_4.projection2(); - BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::INTERCONNECTNODE >, nota_v2::SOCKET > _tmp_6 = _tmp_4.projection1(); - nota_v2::SOCKET _tmp_7 = _tmp_6.projection2(); - BTuple<nota_v2::INTERCONNECTNODE, nota_v2::INTERCONNECTNODE > _tmp_8 = _tmp_6.projection1(); - nota_v2::INTERCONNECTNODE _tmp_9 = _tmp_8.projection2(); - nota_v2::INTERCONNECTNODE _tmp_10 = _tmp_8.projection1(); - - nota_v2 copiedState = state._copy(); - nota_v2::_ProjectionRead_in_requestTargetSocket_Granted readState = state._projected_state_for_in_requestTargetSocket_Granted(); - - auto _OpCache_with_parameter_in_requestTargetSocket_Granted_ptr = _OpCache_in_requestTargetSocket_Granted.find(param); - if(_OpCache_with_parameter_in_requestTargetSocket_Granted_ptr == _OpCache_in_requestTargetSocket_Granted.end()) { - copiedState.in_requestTargetSocket_Granted(_tmp_10, _tmp_9, _tmp_7, _tmp_5, _tmp_3, _tmp_1); - nota_v2::_ProjectionWrite_in_requestTargetSocket_Granted writeState = copiedState._update_for_in_requestTargetSocket_Granted(); - std::unordered_map<nota_v2::_ProjectionRead_in_requestTargetSocket_Granted, nota_v2::_ProjectionWrite_in_requestTargetSocket_Granted, nota_v2::_ProjectionRead_in_requestTargetSocket_Granted::Hash, nota_v2::_ProjectionRead_in_requestTargetSocket_Granted::HashEqual> _OpCache_with_parameter_in_requestTargetSocket_Granted; - _OpCache_with_parameter_in_requestTargetSocket_Granted.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_in_requestTargetSocket_Granted_lock(_ProjectionRead_in_requestTargetSocket_Granted_mutex); - _OpCache_in_requestTargetSocket_Granted.insert({param, _OpCache_with_parameter_in_requestTargetSocket_Granted}); - } + } else { + _trid_12 = _trid_12_ptr->second; + } - } else { - std::unordered_map<nota_v2::_ProjectionRead_in_requestTargetSocket_Granted, nota_v2::_ProjectionWrite_in_requestTargetSocket_Granted, nota_v2::_ProjectionRead_in_requestTargetSocket_Granted::Hash, nota_v2::_ProjectionRead_in_requestTargetSocket_Granted::HashEqual> _OpCache_with_parameter_in_requestTargetSocket_Granted = _OpCache_with_parameter_in_requestTargetSocket_Granted_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_in_requestTargetSocket_Granted.find(readState); - if(writeState_ptr != _OpCache_with_parameter_in_requestTargetSocket_Granted.end()) { - nota_v2::_ProjectionWrite_in_requestTargetSocket_Granted writeState = writeState_ptr->second; - copiedState._apply_update_for_in_requestTargetSocket_Granted(writeState); - } else { - copiedState.in_requestTargetSocket_Granted(_tmp_10, _tmp_9, _tmp_7, _tmp_5, _tmp_3, _tmp_1); - nota_v2::_ProjectionWrite_in_requestTargetSocket_Granted writeState = copiedState._update_for_in_requestTargetSocket_Granted(); - { - std::unique_lock<std::mutex> _ProjectionRead_in_requestTargetSocket_Granted_lock(_ProjectionRead_in_requestTargetSocket_Granted_mutex); - _OpCache_with_parameter_in_requestTargetSocket_Granted.insert({readState, writeState}); - } - } + for(const BTuple<BTuple<BTuple<BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::INTERCONNECTNODE >, nota_v2::SOCKET >, nota_v2::SID >, nota_v2::SID >, nota_v2::SOCKET >& param : _trid_12) { + nota_v2::SOCKET _tmp_1 = param.projection2(); + BTuple<BTuple<BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::INTERCONNECTNODE >, nota_v2::SOCKET >, nota_v2::SID >, nota_v2::SID > _tmp_2 = param.projection1(); + nota_v2::SID _tmp_3 = _tmp_2.projection2(); + BTuple<BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::INTERCONNECTNODE >, nota_v2::SOCKET >, nota_v2::SID > _tmp_4 = _tmp_2.projection1(); + nota_v2::SID _tmp_5 = _tmp_4.projection2(); + BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::INTERCONNECTNODE >, nota_v2::SOCKET > _tmp_6 = _tmp_4.projection1(); + nota_v2::SOCKET _tmp_7 = _tmp_6.projection2(); + BTuple<nota_v2::INTERCONNECTNODE, nota_v2::INTERCONNECTNODE > _tmp_8 = _tmp_6.projection1(); + nota_v2::INTERCONNECTNODE _tmp_9 = _tmp_8.projection2(); + nota_v2::INTERCONNECTNODE _tmp_10 = _tmp_8.projection1(); + + nota_v2 copiedState = state._copy(); + nota_v2::_ProjectionRead_in_requestTargetSocket_Granted readState = state._projected_state_for_in_requestTargetSocket_Granted(); + + auto _OpCache_with_parameter_in_requestTargetSocket_Granted_ptr = _OpCache_in_requestTargetSocket_Granted.find(param); + if(_OpCache_with_parameter_in_requestTargetSocket_Granted_ptr == _OpCache_in_requestTargetSocket_Granted.end()) { + copiedState.in_requestTargetSocket_Granted(_tmp_10, _tmp_9, _tmp_7, _tmp_5, _tmp_3, _tmp_1); + nota_v2::_ProjectionWrite_in_requestTargetSocket_Granted writeState = copiedState._update_for_in_requestTargetSocket_Granted(); + std::unordered_map<nota_v2::_ProjectionRead_in_requestTargetSocket_Granted, nota_v2::_ProjectionWrite_in_requestTargetSocket_Granted, nota_v2::_ProjectionRead_in_requestTargetSocket_Granted::Hash, nota_v2::_ProjectionRead_in_requestTargetSocket_Granted::HashEqual> _OpCache_with_parameter_in_requestTargetSocket_Granted; + _OpCache_with_parameter_in_requestTargetSocket_Granted.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_in_requestTargetSocket_Granted_lock(_ProjectionRead_in_requestTargetSocket_Granted_mutex); + _OpCache_in_requestTargetSocket_Granted.insert({param, _OpCache_with_parameter_in_requestTargetSocket_Granted}); } - copiedState.stateAccessedVia = "in_requestTargetSocket_Granted"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<BTuple<BTuple<BTuple<BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::INTERCONNECTNODE >, nota_v2::SOCKET >, nota_v2::SID >, nota_v2::SID >, nota_v2::SOCKET >> _trid_12 = _trid_12_ptr->second; - for(const BTuple<BTuple<BTuple<BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::INTERCONNECTNODE >, nota_v2::SOCKET >, nota_v2::SID >, nota_v2::SID >, nota_v2::SOCKET >& param : _trid_12) { - nota_v2::SOCKET _tmp_1 = param.projection2(); - BTuple<BTuple<BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::INTERCONNECTNODE >, nota_v2::SOCKET >, nota_v2::SID >, nota_v2::SID > _tmp_2 = param.projection1(); - nota_v2::SID _tmp_3 = _tmp_2.projection2(); - BTuple<BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::INTERCONNECTNODE >, nota_v2::SOCKET >, nota_v2::SID > _tmp_4 = _tmp_2.projection1(); - nota_v2::SID _tmp_5 = _tmp_4.projection2(); - BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::INTERCONNECTNODE >, nota_v2::SOCKET > _tmp_6 = _tmp_4.projection1(); - nota_v2::SOCKET _tmp_7 = _tmp_6.projection2(); - BTuple<nota_v2::INTERCONNECTNODE, nota_v2::INTERCONNECTNODE > _tmp_8 = _tmp_6.projection1(); - nota_v2::INTERCONNECTNODE _tmp_9 = _tmp_8.projection2(); - nota_v2::INTERCONNECTNODE _tmp_10 = _tmp_8.projection1(); - - nota_v2 copiedState = state._copy(); - nota_v2::_ProjectionRead_in_requestTargetSocket_Granted readState = state._projected_state_for_in_requestTargetSocket_Granted(); - - auto _OpCache_with_parameter_in_requestTargetSocket_Granted_ptr = _OpCache_in_requestTargetSocket_Granted.find(param); - if(_OpCache_with_parameter_in_requestTargetSocket_Granted_ptr == _OpCache_in_requestTargetSocket_Granted.end()) { + } else { + std::unordered_map<nota_v2::_ProjectionRead_in_requestTargetSocket_Granted, nota_v2::_ProjectionWrite_in_requestTargetSocket_Granted, nota_v2::_ProjectionRead_in_requestTargetSocket_Granted::Hash, nota_v2::_ProjectionRead_in_requestTargetSocket_Granted::HashEqual> _OpCache_with_parameter_in_requestTargetSocket_Granted = _OpCache_with_parameter_in_requestTargetSocket_Granted_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_in_requestTargetSocket_Granted.find(readState); + if(writeState_ptr != _OpCache_with_parameter_in_requestTargetSocket_Granted.end()) { + nota_v2::_ProjectionWrite_in_requestTargetSocket_Granted writeState = writeState_ptr->second; + copiedState._apply_update_for_in_requestTargetSocket_Granted(writeState); + } else { copiedState.in_requestTargetSocket_Granted(_tmp_10, _tmp_9, _tmp_7, _tmp_5, _tmp_3, _tmp_1); nota_v2::_ProjectionWrite_in_requestTargetSocket_Granted writeState = copiedState._update_for_in_requestTargetSocket_Granted(); - std::unordered_map<nota_v2::_ProjectionRead_in_requestTargetSocket_Granted, nota_v2::_ProjectionWrite_in_requestTargetSocket_Granted, nota_v2::_ProjectionRead_in_requestTargetSocket_Granted::Hash, nota_v2::_ProjectionRead_in_requestTargetSocket_Granted::HashEqual> _OpCache_with_parameter_in_requestTargetSocket_Granted; - _OpCache_with_parameter_in_requestTargetSocket_Granted.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_in_requestTargetSocket_Granted_lock(_ProjectionRead_in_requestTargetSocket_Granted_mutex); - _OpCache_in_requestTargetSocket_Granted.insert({param, _OpCache_with_parameter_in_requestTargetSocket_Granted}); - } - - } else { - std::unordered_map<nota_v2::_ProjectionRead_in_requestTargetSocket_Granted, nota_v2::_ProjectionWrite_in_requestTargetSocket_Granted, nota_v2::_ProjectionRead_in_requestTargetSocket_Granted::Hash, nota_v2::_ProjectionRead_in_requestTargetSocket_Granted::HashEqual> _OpCache_with_parameter_in_requestTargetSocket_Granted = _OpCache_with_parameter_in_requestTargetSocket_Granted_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_in_requestTargetSocket_Granted.find(readState); - if(writeState_ptr != _OpCache_with_parameter_in_requestTargetSocket_Granted.end()) { - nota_v2::_ProjectionWrite_in_requestTargetSocket_Granted writeState = writeState_ptr->second; - copiedState._apply_update_for_in_requestTargetSocket_Granted(writeState); - } else { - copiedState.in_requestTargetSocket_Granted(_tmp_10, _tmp_9, _tmp_7, _tmp_5, _tmp_3, _tmp_1); - nota_v2::_ProjectionWrite_in_requestTargetSocket_Granted writeState = copiedState._update_for_in_requestTargetSocket_Granted(); - { - std::unique_lock<std::mutex> _ProjectionRead_in_requestTargetSocket_Granted_lock(_ProjectionRead_in_requestTargetSocket_Granted_mutex); - _OpCache_with_parameter_in_requestTargetSocket_Granted.insert({readState, writeState}); - } + _OpCache_with_parameter_in_requestTargetSocket_Granted.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "in_requestTargetSocket_Granted"; - result.insert(copiedState); + copiedState.stateAccessedVia = "in_requestTargetSocket_Granted"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } nota_v2::_ProjectionRead__tr_in_requestTargetSocket_NotGranted read__tr_in_requestTargetSocket_NotGranted_state = state._projected_state_for__tr_in_requestTargetSocket_NotGranted(); + BSet<BTuple<BTuple<BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::INTERCONNECTNODE >, nota_v2::SOCKET >, nota_v2::SID >, nota_v2::SID >> _trid_13; auto _trid_13_ptr = _OpCache_tr_in_requestTargetSocket_NotGranted.find(read__tr_in_requestTargetSocket_NotGranted_state); if(_trid_13_ptr == _OpCache_tr_in_requestTargetSocket_NotGranted.end()) { - BSet<BTuple<BTuple<BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::INTERCONNECTNODE >, nota_v2::SOCKET >, nota_v2::SID >, nota_v2::SID >> _trid_13 = state._tr_in_requestTargetSocket_NotGranted(); + _trid_13 = state._tr_in_requestTargetSocket_NotGranted(); { std::unique_lock<std::mutex> _ProjectionRead__tr_in_requestTargetSocket_NotGranted_lock(_ProjectionRead__tr_in_requestTargetSocket_NotGranted_mutex); _OpCache_tr_in_requestTargetSocket_NotGranted.insert({read__tr_in_requestTargetSocket_NotGranted_state, _trid_13}); } - for(const BTuple<BTuple<BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::INTERCONNECTNODE >, nota_v2::SOCKET >, nota_v2::SID >, nota_v2::SID >& param : _trid_13) { - nota_v2::SID _tmp_1 = param.projection2(); - BTuple<BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::INTERCONNECTNODE >, nota_v2::SOCKET >, nota_v2::SID > _tmp_2 = param.projection1(); - nota_v2::SID _tmp_3 = _tmp_2.projection2(); - BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::INTERCONNECTNODE >, nota_v2::SOCKET > _tmp_4 = _tmp_2.projection1(); - nota_v2::SOCKET _tmp_5 = _tmp_4.projection2(); - BTuple<nota_v2::INTERCONNECTNODE, nota_v2::INTERCONNECTNODE > _tmp_6 = _tmp_4.projection1(); - nota_v2::INTERCONNECTNODE _tmp_7 = _tmp_6.projection2(); - nota_v2::INTERCONNECTNODE _tmp_8 = _tmp_6.projection1(); - - nota_v2 copiedState = state._copy(); - nota_v2::_ProjectionRead_in_requestTargetSocket_NotGranted readState = state._projected_state_for_in_requestTargetSocket_NotGranted(); - - auto _OpCache_with_parameter_in_requestTargetSocket_NotGranted_ptr = _OpCache_in_requestTargetSocket_NotGranted.find(param); - if(_OpCache_with_parameter_in_requestTargetSocket_NotGranted_ptr == _OpCache_in_requestTargetSocket_NotGranted.end()) { - copiedState.in_requestTargetSocket_NotGranted(_tmp_8, _tmp_7, _tmp_5, _tmp_3, _tmp_1); - nota_v2::_ProjectionWrite_in_requestTargetSocket_NotGranted writeState = copiedState._update_for_in_requestTargetSocket_NotGranted(); - std::unordered_map<nota_v2::_ProjectionRead_in_requestTargetSocket_NotGranted, nota_v2::_ProjectionWrite_in_requestTargetSocket_NotGranted, nota_v2::_ProjectionRead_in_requestTargetSocket_NotGranted::Hash, nota_v2::_ProjectionRead_in_requestTargetSocket_NotGranted::HashEqual> _OpCache_with_parameter_in_requestTargetSocket_NotGranted; - _OpCache_with_parameter_in_requestTargetSocket_NotGranted.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_in_requestTargetSocket_NotGranted_lock(_ProjectionRead_in_requestTargetSocket_NotGranted_mutex); - _OpCache_in_requestTargetSocket_NotGranted.insert({param, _OpCache_with_parameter_in_requestTargetSocket_NotGranted}); - } + } else { + _trid_13 = _trid_13_ptr->second; + } - } else { - std::unordered_map<nota_v2::_ProjectionRead_in_requestTargetSocket_NotGranted, nota_v2::_ProjectionWrite_in_requestTargetSocket_NotGranted, nota_v2::_ProjectionRead_in_requestTargetSocket_NotGranted::Hash, nota_v2::_ProjectionRead_in_requestTargetSocket_NotGranted::HashEqual> _OpCache_with_parameter_in_requestTargetSocket_NotGranted = _OpCache_with_parameter_in_requestTargetSocket_NotGranted_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_in_requestTargetSocket_NotGranted.find(readState); - if(writeState_ptr != _OpCache_with_parameter_in_requestTargetSocket_NotGranted.end()) { - nota_v2::_ProjectionWrite_in_requestTargetSocket_NotGranted writeState = writeState_ptr->second; - copiedState._apply_update_for_in_requestTargetSocket_NotGranted(writeState); - } else { - copiedState.in_requestTargetSocket_NotGranted(_tmp_8, _tmp_7, _tmp_5, _tmp_3, _tmp_1); - nota_v2::_ProjectionWrite_in_requestTargetSocket_NotGranted writeState = copiedState._update_for_in_requestTargetSocket_NotGranted(); - { - std::unique_lock<std::mutex> _ProjectionRead_in_requestTargetSocket_NotGranted_lock(_ProjectionRead_in_requestTargetSocket_NotGranted_mutex); - _OpCache_with_parameter_in_requestTargetSocket_NotGranted.insert({readState, writeState}); - } - } + for(const BTuple<BTuple<BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::INTERCONNECTNODE >, nota_v2::SOCKET >, nota_v2::SID >, nota_v2::SID >& param : _trid_13) { + nota_v2::SID _tmp_1 = param.projection2(); + BTuple<BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::INTERCONNECTNODE >, nota_v2::SOCKET >, nota_v2::SID > _tmp_2 = param.projection1(); + nota_v2::SID _tmp_3 = _tmp_2.projection2(); + BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::INTERCONNECTNODE >, nota_v2::SOCKET > _tmp_4 = _tmp_2.projection1(); + nota_v2::SOCKET _tmp_5 = _tmp_4.projection2(); + BTuple<nota_v2::INTERCONNECTNODE, nota_v2::INTERCONNECTNODE > _tmp_6 = _tmp_4.projection1(); + nota_v2::INTERCONNECTNODE _tmp_7 = _tmp_6.projection2(); + nota_v2::INTERCONNECTNODE _tmp_8 = _tmp_6.projection1(); + + nota_v2 copiedState = state._copy(); + nota_v2::_ProjectionRead_in_requestTargetSocket_NotGranted readState = state._projected_state_for_in_requestTargetSocket_NotGranted(); + + auto _OpCache_with_parameter_in_requestTargetSocket_NotGranted_ptr = _OpCache_in_requestTargetSocket_NotGranted.find(param); + if(_OpCache_with_parameter_in_requestTargetSocket_NotGranted_ptr == _OpCache_in_requestTargetSocket_NotGranted.end()) { + copiedState.in_requestTargetSocket_NotGranted(_tmp_8, _tmp_7, _tmp_5, _tmp_3, _tmp_1); + nota_v2::_ProjectionWrite_in_requestTargetSocket_NotGranted writeState = copiedState._update_for_in_requestTargetSocket_NotGranted(); + std::unordered_map<nota_v2::_ProjectionRead_in_requestTargetSocket_NotGranted, nota_v2::_ProjectionWrite_in_requestTargetSocket_NotGranted, nota_v2::_ProjectionRead_in_requestTargetSocket_NotGranted::Hash, nota_v2::_ProjectionRead_in_requestTargetSocket_NotGranted::HashEqual> _OpCache_with_parameter_in_requestTargetSocket_NotGranted; + _OpCache_with_parameter_in_requestTargetSocket_NotGranted.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_in_requestTargetSocket_NotGranted_lock(_ProjectionRead_in_requestTargetSocket_NotGranted_mutex); + _OpCache_in_requestTargetSocket_NotGranted.insert({param, _OpCache_with_parameter_in_requestTargetSocket_NotGranted}); } - copiedState.stateAccessedVia = "in_requestTargetSocket_NotGranted"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<BTuple<BTuple<BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::INTERCONNECTNODE >, nota_v2::SOCKET >, nota_v2::SID >, nota_v2::SID >> _trid_13 = _trid_13_ptr->second; - for(const BTuple<BTuple<BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::INTERCONNECTNODE >, nota_v2::SOCKET >, nota_v2::SID >, nota_v2::SID >& param : _trid_13) { - nota_v2::SID _tmp_1 = param.projection2(); - BTuple<BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::INTERCONNECTNODE >, nota_v2::SOCKET >, nota_v2::SID > _tmp_2 = param.projection1(); - nota_v2::SID _tmp_3 = _tmp_2.projection2(); - BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::INTERCONNECTNODE >, nota_v2::SOCKET > _tmp_4 = _tmp_2.projection1(); - nota_v2::SOCKET _tmp_5 = _tmp_4.projection2(); - BTuple<nota_v2::INTERCONNECTNODE, nota_v2::INTERCONNECTNODE > _tmp_6 = _tmp_4.projection1(); - nota_v2::INTERCONNECTNODE _tmp_7 = _tmp_6.projection2(); - nota_v2::INTERCONNECTNODE _tmp_8 = _tmp_6.projection1(); - - nota_v2 copiedState = state._copy(); - nota_v2::_ProjectionRead_in_requestTargetSocket_NotGranted readState = state._projected_state_for_in_requestTargetSocket_NotGranted(); - - auto _OpCache_with_parameter_in_requestTargetSocket_NotGranted_ptr = _OpCache_in_requestTargetSocket_NotGranted.find(param); - if(_OpCache_with_parameter_in_requestTargetSocket_NotGranted_ptr == _OpCache_in_requestTargetSocket_NotGranted.end()) { + } else { + std::unordered_map<nota_v2::_ProjectionRead_in_requestTargetSocket_NotGranted, nota_v2::_ProjectionWrite_in_requestTargetSocket_NotGranted, nota_v2::_ProjectionRead_in_requestTargetSocket_NotGranted::Hash, nota_v2::_ProjectionRead_in_requestTargetSocket_NotGranted::HashEqual> _OpCache_with_parameter_in_requestTargetSocket_NotGranted = _OpCache_with_parameter_in_requestTargetSocket_NotGranted_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_in_requestTargetSocket_NotGranted.find(readState); + if(writeState_ptr != _OpCache_with_parameter_in_requestTargetSocket_NotGranted.end()) { + nota_v2::_ProjectionWrite_in_requestTargetSocket_NotGranted writeState = writeState_ptr->second; + copiedState._apply_update_for_in_requestTargetSocket_NotGranted(writeState); + } else { copiedState.in_requestTargetSocket_NotGranted(_tmp_8, _tmp_7, _tmp_5, _tmp_3, _tmp_1); nota_v2::_ProjectionWrite_in_requestTargetSocket_NotGranted writeState = copiedState._update_for_in_requestTargetSocket_NotGranted(); - std::unordered_map<nota_v2::_ProjectionRead_in_requestTargetSocket_NotGranted, nota_v2::_ProjectionWrite_in_requestTargetSocket_NotGranted, nota_v2::_ProjectionRead_in_requestTargetSocket_NotGranted::Hash, nota_v2::_ProjectionRead_in_requestTargetSocket_NotGranted::HashEqual> _OpCache_with_parameter_in_requestTargetSocket_NotGranted; - _OpCache_with_parameter_in_requestTargetSocket_NotGranted.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_in_requestTargetSocket_NotGranted_lock(_ProjectionRead_in_requestTargetSocket_NotGranted_mutex); - _OpCache_in_requestTargetSocket_NotGranted.insert({param, _OpCache_with_parameter_in_requestTargetSocket_NotGranted}); - } - - } else { - std::unordered_map<nota_v2::_ProjectionRead_in_requestTargetSocket_NotGranted, nota_v2::_ProjectionWrite_in_requestTargetSocket_NotGranted, nota_v2::_ProjectionRead_in_requestTargetSocket_NotGranted::Hash, nota_v2::_ProjectionRead_in_requestTargetSocket_NotGranted::HashEqual> _OpCache_with_parameter_in_requestTargetSocket_NotGranted = _OpCache_with_parameter_in_requestTargetSocket_NotGranted_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_in_requestTargetSocket_NotGranted.find(readState); - if(writeState_ptr != _OpCache_with_parameter_in_requestTargetSocket_NotGranted.end()) { - nota_v2::_ProjectionWrite_in_requestTargetSocket_NotGranted writeState = writeState_ptr->second; - copiedState._apply_update_for_in_requestTargetSocket_NotGranted(writeState); - } else { - copiedState.in_requestTargetSocket_NotGranted(_tmp_8, _tmp_7, _tmp_5, _tmp_3, _tmp_1); - nota_v2::_ProjectionWrite_in_requestTargetSocket_NotGranted writeState = copiedState._update_for_in_requestTargetSocket_NotGranted(); - { - std::unique_lock<std::mutex> _ProjectionRead_in_requestTargetSocket_NotGranted_lock(_ProjectionRead_in_requestTargetSocket_NotGranted_mutex); - _OpCache_with_parameter_in_requestTargetSocket_NotGranted.insert({readState, writeState}); - } + _OpCache_with_parameter_in_requestTargetSocket_NotGranted.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "in_requestTargetSocket_NotGranted"; - result.insert(copiedState); + copiedState.stateAccessedVia = "in_requestTargetSocket_NotGranted"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } nota_v2::_ProjectionRead__tr_svc_register read__tr_svc_register_state = state._projected_state_for__tr_svc_register(); + BSet<nota_v2::SERVICE> _trid_14; auto _trid_14_ptr = _OpCache_tr_svc_register.find(read__tr_svc_register_state); if(_trid_14_ptr == _OpCache_tr_svc_register.end()) { - BSet<nota_v2::SERVICE> _trid_14 = state._tr_svc_register(); + _trid_14 = state._tr_svc_register(); { std::unique_lock<std::mutex> _ProjectionRead__tr_svc_register_lock(_ProjectionRead__tr_svc_register_mutex); _OpCache_tr_svc_register.insert({read__tr_svc_register_state, _trid_14}); } - for(const nota_v2::SERVICE& param : _trid_14) { - nota_v2::SERVICE _tmp_1 = param; - - nota_v2 copiedState = state._copy(); - nota_v2::_ProjectionRead_svc_register readState = state._projected_state_for_svc_register(); + } else { + _trid_14 = _trid_14_ptr->second; + } - auto _OpCache_with_parameter_svc_register_ptr = _OpCache_svc_register.find(param); - if(_OpCache_with_parameter_svc_register_ptr == _OpCache_svc_register.end()) { - copiedState.svc_register(_tmp_1); - nota_v2::_ProjectionWrite_svc_register writeState = copiedState._update_for_svc_register(); - std::unordered_map<nota_v2::_ProjectionRead_svc_register, nota_v2::_ProjectionWrite_svc_register, nota_v2::_ProjectionRead_svc_register::Hash, nota_v2::_ProjectionRead_svc_register::HashEqual> _OpCache_with_parameter_svc_register; - _OpCache_with_parameter_svc_register.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_svc_register_lock(_ProjectionRead_svc_register_mutex); - _OpCache_svc_register.insert({param, _OpCache_with_parameter_svc_register}); - } + for(const nota_v2::SERVICE& param : _trid_14) { + nota_v2::SERVICE _tmp_1 = param; - } else { - std::unordered_map<nota_v2::_ProjectionRead_svc_register, nota_v2::_ProjectionWrite_svc_register, nota_v2::_ProjectionRead_svc_register::Hash, nota_v2::_ProjectionRead_svc_register::HashEqual> _OpCache_with_parameter_svc_register = _OpCache_with_parameter_svc_register_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_svc_register.find(readState); - if(writeState_ptr != _OpCache_with_parameter_svc_register.end()) { - nota_v2::_ProjectionWrite_svc_register writeState = writeState_ptr->second; - copiedState._apply_update_for_svc_register(writeState); - } else { - copiedState.svc_register(_tmp_1); - nota_v2::_ProjectionWrite_svc_register writeState = copiedState._update_for_svc_register(); - { - std::unique_lock<std::mutex> _ProjectionRead_svc_register_lock(_ProjectionRead_svc_register_mutex); - _OpCache_with_parameter_svc_register.insert({readState, writeState}); - } - } + nota_v2 copiedState = state._copy(); + nota_v2::_ProjectionRead_svc_register readState = state._projected_state_for_svc_register(); + + auto _OpCache_with_parameter_svc_register_ptr = _OpCache_svc_register.find(param); + if(_OpCache_with_parameter_svc_register_ptr == _OpCache_svc_register.end()) { + copiedState.svc_register(_tmp_1); + nota_v2::_ProjectionWrite_svc_register writeState = copiedState._update_for_svc_register(); + std::unordered_map<nota_v2::_ProjectionRead_svc_register, nota_v2::_ProjectionWrite_svc_register, nota_v2::_ProjectionRead_svc_register::Hash, nota_v2::_ProjectionRead_svc_register::HashEqual> _OpCache_with_parameter_svc_register; + _OpCache_with_parameter_svc_register.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_svc_register_lock(_ProjectionRead_svc_register_mutex); + _OpCache_svc_register.insert({param, _OpCache_with_parameter_svc_register}); } - copiedState.stateAccessedVia = "svc_register"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<nota_v2::SERVICE> _trid_14 = _trid_14_ptr->second; - for(const nota_v2::SERVICE& param : _trid_14) { - nota_v2::SERVICE _tmp_1 = param; - - nota_v2 copiedState = state._copy(); - nota_v2::_ProjectionRead_svc_register readState = state._projected_state_for_svc_register(); - - auto _OpCache_with_parameter_svc_register_ptr = _OpCache_svc_register.find(param); - if(_OpCache_with_parameter_svc_register_ptr == _OpCache_svc_register.end()) { + } else { + std::unordered_map<nota_v2::_ProjectionRead_svc_register, nota_v2::_ProjectionWrite_svc_register, nota_v2::_ProjectionRead_svc_register::Hash, nota_v2::_ProjectionRead_svc_register::HashEqual> _OpCache_with_parameter_svc_register = _OpCache_with_parameter_svc_register_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_svc_register.find(readState); + if(writeState_ptr != _OpCache_with_parameter_svc_register.end()) { + nota_v2::_ProjectionWrite_svc_register writeState = writeState_ptr->second; + copiedState._apply_update_for_svc_register(writeState); + } else { copiedState.svc_register(_tmp_1); nota_v2::_ProjectionWrite_svc_register writeState = copiedState._update_for_svc_register(); - std::unordered_map<nota_v2::_ProjectionRead_svc_register, nota_v2::_ProjectionWrite_svc_register, nota_v2::_ProjectionRead_svc_register::Hash, nota_v2::_ProjectionRead_svc_register::HashEqual> _OpCache_with_parameter_svc_register; - _OpCache_with_parameter_svc_register.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_svc_register_lock(_ProjectionRead_svc_register_mutex); - _OpCache_svc_register.insert({param, _OpCache_with_parameter_svc_register}); - } - - } else { - std::unordered_map<nota_v2::_ProjectionRead_svc_register, nota_v2::_ProjectionWrite_svc_register, nota_v2::_ProjectionRead_svc_register::Hash, nota_v2::_ProjectionRead_svc_register::HashEqual> _OpCache_with_parameter_svc_register = _OpCache_with_parameter_svc_register_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_svc_register.find(readState); - if(writeState_ptr != _OpCache_with_parameter_svc_register.end()) { - nota_v2::_ProjectionWrite_svc_register writeState = writeState_ptr->second; - copiedState._apply_update_for_svc_register(writeState); - } else { - copiedState.svc_register(_tmp_1); - nota_v2::_ProjectionWrite_svc_register writeState = copiedState._update_for_svc_register(); - { - std::unique_lock<std::mutex> _ProjectionRead_svc_register_lock(_ProjectionRead_svc_register_mutex); - _OpCache_with_parameter_svc_register.insert({readState, writeState}); - } + _OpCache_with_parameter_svc_register.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "svc_register"; - result.insert(copiedState); + copiedState.stateAccessedVia = "svc_register"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } @@ -6633,7 +6158,10 @@ class ModelChecker { copiedState.constructor_interconnectNode(_tmp_1); copiedState.stateAccessedVia = "constructor_interconnectNode"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<nota_v2::RESOURCEMANAGER> _trid_2 = state._tr_constructor_resourceManager(); for(const nota_v2::RESOURCEMANAGER& param : _trid_2) { @@ -6643,7 +6171,10 @@ class ModelChecker { copiedState.constructor_resourceManager(_tmp_1); copiedState.stateAccessedVia = "constructor_resourceManager"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::SERVICE >> _trid_3 = state._tr_constructor_service(); for(const BTuple<nota_v2::INTERCONNECTNODE, nota_v2::SERVICE >& param : _trid_3) { @@ -6654,7 +6185,10 @@ class ModelChecker { copiedState.constructor_service(_tmp_2, _tmp_1); copiedState.stateAccessedVia = "constructor_service"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<BTuple<BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::SID >, nota_v2::SID >, nota_v2::SOCKET >> _trid_4 = state._tr_constructor_socket(); for(const BTuple<BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::SID >, nota_v2::SID >, nota_v2::SOCKET >& param : _trid_4) { @@ -6669,7 +6203,10 @@ class ModelChecker { copiedState.constructor_socket(_tmp_6, _tmp_5, _tmp_3, _tmp_1); copiedState.stateAccessedVia = "constructor_socket"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<BTuple<BTuple<nota_v2::RESOURCEMANAGER, nota_v2::SERVICE >, nota_v2::INTERCONNECTNODE >> _trid_5 = state._tr_rm_register(); for(const BTuple<BTuple<nota_v2::RESOURCEMANAGER, nota_v2::SERVICE >, nota_v2::INTERCONNECTNODE >& param : _trid_5) { @@ -6682,7 +6219,10 @@ class ModelChecker { copiedState.rm_register(_tmp_4, _tmp_3, _tmp_1); copiedState.stateAccessedVia = "rm_register"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<BTuple<BTuple<nota_v2::RESOURCEMANAGER, nota_v2::SERVICE >, nota_v2::INTERCONNECTNODE >> _trid_6 = state._tr_rm_deregister(); for(const BTuple<BTuple<nota_v2::RESOURCEMANAGER, nota_v2::SERVICE >, nota_v2::INTERCONNECTNODE >& param : _trid_6) { @@ -6695,7 +6235,10 @@ class ModelChecker { copiedState.rm_deregister(_tmp_4, _tmp_3, _tmp_1); copiedState.stateAccessedVia = "rm_deregister"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<BTuple<nota_v2::RESOURCEMANAGER, nota_v2::SERVICE >> _trid_7 = state._tr_rm_getSid(); for(const BTuple<nota_v2::RESOURCEMANAGER, nota_v2::SERVICE >& param : _trid_7) { @@ -6706,7 +6249,10 @@ class ModelChecker { copiedState.rm_getSid(_tmp_2, _tmp_1); copiedState.stateAccessedVia = "rm_getSid"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<BTuple<nota_v2::RESOURCEMANAGER, nota_v2::SERVICE >> _trid_8 = state._tr_rm_getSid_Not_Found(); for(const BTuple<nota_v2::RESOURCEMANAGER, nota_v2::SERVICE >& param : _trid_8) { @@ -6717,7 +6263,10 @@ class ModelChecker { copiedState.rm_getSid_Not_Found(_tmp_2, _tmp_1); copiedState.stateAccessedVia = "rm_getSid_Not_Found"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::RESOURCEMANAGER >> _trid_9 = state._tr_in_announceResourceManager(); for(const BTuple<nota_v2::INTERCONNECTNODE, nota_v2::RESOURCEMANAGER >& param : _trid_9) { @@ -6728,7 +6277,10 @@ class ModelChecker { copiedState.in_announceResourceManager(_tmp_2, _tmp_1); copiedState.stateAccessedVia = "in_announceResourceManager"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::SERVICE >, nota_v2::SID >> _trid_10 = state._tr_in_register_success(); for(const BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::SERVICE >, nota_v2::SID >& param : _trid_10) { @@ -6741,7 +6293,10 @@ class ModelChecker { copiedState.in_register_success(_tmp_4, _tmp_3, _tmp_1); copiedState.stateAccessedVia = "in_register_success"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::SERVICE >> _trid_11 = state._tr_in_register_failed(); for(const BTuple<nota_v2::INTERCONNECTNODE, nota_v2::SERVICE >& param : _trid_11) { @@ -6752,7 +6307,10 @@ class ModelChecker { copiedState.in_register_failed(_tmp_2, _tmp_1); copiedState.stateAccessedVia = "in_register_failed"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<BTuple<BTuple<BTuple<BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::INTERCONNECTNODE >, nota_v2::SOCKET >, nota_v2::SID >, nota_v2::SID >, nota_v2::SOCKET >> _trid_12 = state._tr_in_requestTargetSocket_Granted(); for(const BTuple<BTuple<BTuple<BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::INTERCONNECTNODE >, nota_v2::SOCKET >, nota_v2::SID >, nota_v2::SID >, nota_v2::SOCKET >& param : _trid_12) { @@ -6771,7 +6329,10 @@ class ModelChecker { copiedState.in_requestTargetSocket_Granted(_tmp_10, _tmp_9, _tmp_7, _tmp_5, _tmp_3, _tmp_1); copiedState.stateAccessedVia = "in_requestTargetSocket_Granted"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<BTuple<BTuple<BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::INTERCONNECTNODE >, nota_v2::SOCKET >, nota_v2::SID >, nota_v2::SID >> _trid_13 = state._tr_in_requestTargetSocket_NotGranted(); for(const BTuple<BTuple<BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::INTERCONNECTNODE >, nota_v2::SOCKET >, nota_v2::SID >, nota_v2::SID >& param : _trid_13) { @@ -6788,7 +6349,10 @@ class ModelChecker { copiedState.in_requestTargetSocket_NotGranted(_tmp_8, _tmp_7, _tmp_5, _tmp_3, _tmp_1); copiedState.stateAccessedVia = "in_requestTargetSocket_NotGranted"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<nota_v2::SERVICE> _trid_14 = state._tr_svc_register(); for(const nota_v2::SERVICE& param : _trid_14) { @@ -6798,7 +6362,10 @@ class ModelChecker { copiedState.svc_register(_tmp_1); copiedState.stateAccessedVia = "svc_register"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } } diff --git a/benchmarks/model_checking_opreuse/C++/obsw_M001_1.cpp b/benchmarks/model_checking_opreuse/C++/obsw_M001_1.cpp index c0876aa0d4d091e1cc05eb05f702e3e8de6fa057..add4539c66f9544dfaff2a535a5dd8528031ab84 100644 --- a/benchmarks/model_checking_opreuse/C++/obsw_M001_1.cpp +++ b/benchmarks/model_checking_opreuse/C++/obsw_M001_1.cpp @@ -10,7 +10,6 @@ #include <atomic> #include <any> #include <mutex> -#include <shared_mutex> #include <future> #include <boost/asio/post.hpp> #include <boost/asio/thread_pool.hpp> @@ -5597,12 +5596,16 @@ class ModelChecker { states.insert(machine); unvisitedStates.push_back(machine); - std::atomic<bool> stopThreads(false); + std::atomic<bool> stopThreads; + stopThreads = false; std::atomic<int> possibleQueueChanges; possibleQueueChanges = 0; - while(!unvisitedStates.empty() && !stopThreads.load()) { - possibleQueueChanges.fetch_add(1); + std::atomic<bool> waitFlag; + waitFlag = true; + + while(!unvisitedStates.empty() && !stopThreads) { + possibleQueueChanges += 1; obsw_M001_1 state = next(); std::packaged_task<void()> task([&, state] { std::unordered_set<obsw_M001_1, obsw_M001_1::Hash, obsw_M001_1::HashEqual> nextStates = generateNextStates(state); @@ -5623,12 +5626,14 @@ class ModelChecker { } } - possibleQueueChanges.fetch_sub(1); { std::unique_lock<std::mutex> lock(mutex); - if (!unvisitedStates.empty() || possibleQueueChanges.load() == 0) { + possibleQueueChanges -= 1; + int running = possibleQueueChanges; + if (!unvisitedStates.empty() || running == 0) { { std::unique_lock<std::mutex> lock(waitMutex); + waitFlag = false; waitCV.notify_one(); } } @@ -5638,24 +5643,27 @@ class ModelChecker { if(invariantViolated(state)) { invariantViolatedBool = true; counterExampleState = state; - stopThreads.store(true); + stopThreads = true; } if(nextStates.empty()) { deadlockDetected = true; counterExampleState = state; - stopThreads.store(true); + stopThreads = true; } }); + waitFlag = true; boost::asio::post(workers, std::move(task)); { std::unique_lock<std::mutex> lock(waitMutex); - waitCV.wait(lock, [&] { - return !unvisitedStates.empty() || possibleQueueChanges == 0; - }); + if(unvisitedStates.empty() && possibleQueueChanges > 0) { + waitCV.wait(lock, [&] { + return waitFlag == false; + }); + } } } workers.join(); @@ -5700,1819 +5708,1131 @@ class ModelChecker { std::unordered_set<obsw_M001_1, obsw_M001_1::Hash, obsw_M001_1::HashEqual> result = std::unordered_set<obsw_M001_1, obsw_M001_1::Hash, obsw_M001_1::HashEqual>(); if(isCaching) { obsw_M001_1::_ProjectionRead__tr_env_Receive_TC read__tr_env_Receive_TC_state = state._projected_state_for__tr_env_Receive_TC(); + BSet<BTuple<obsw_M001_1::TC_SET, obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_BUFFER >> _trid_1; auto _trid_1_ptr = _OpCache_tr_env_Receive_TC.find(read__tr_env_Receive_TC_state); if(_trid_1_ptr == _OpCache_tr_env_Receive_TC.end()) { - BSet<BTuple<obsw_M001_1::TC_SET, obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_BUFFER >> _trid_1 = state._tr_env_Receive_TC(); + _trid_1 = state._tr_env_Receive_TC(); { std::unique_lock<std::mutex> _ProjectionRead__tr_env_Receive_TC_lock(_ProjectionRead__tr_env_Receive_TC_mutex); _OpCache_tr_env_Receive_TC.insert({read__tr_env_Receive_TC_state, _trid_1}); } - for(const BTuple<obsw_M001_1::TC_SET, obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_BUFFER >& param : _trid_1) { - obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_BUFFER _tmp_1 = param.projection2(); - obsw_M001_1::TC_SET _tmp_2 = param.projection1(); - - obsw_M001_1 copiedState = state._copy(); - obsw_M001_1::_ProjectionRead_env_Receive_TC readState = state._projected_state_for_env_Receive_TC(); + } else { + _trid_1 = _trid_1_ptr->second; + } - auto _OpCache_with_parameter_env_Receive_TC_ptr = _OpCache_env_Receive_TC.find(param); - if(_OpCache_with_parameter_env_Receive_TC_ptr == _OpCache_env_Receive_TC.end()) { - copiedState.env_Receive_TC(_tmp_2, _tmp_1); - obsw_M001_1::_ProjectionWrite_env_Receive_TC writeState = copiedState._update_for_env_Receive_TC(); - std::unordered_map<obsw_M001_1::_ProjectionRead_env_Receive_TC, obsw_M001_1::_ProjectionWrite_env_Receive_TC, obsw_M001_1::_ProjectionRead_env_Receive_TC::Hash, obsw_M001_1::_ProjectionRead_env_Receive_TC::HashEqual> _OpCache_with_parameter_env_Receive_TC; - _OpCache_with_parameter_env_Receive_TC.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_env_Receive_TC_lock(_ProjectionRead_env_Receive_TC_mutex); - _OpCache_env_Receive_TC.insert({param, _OpCache_with_parameter_env_Receive_TC}); - } + for(const BTuple<obsw_M001_1::TC_SET, obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_BUFFER >& param : _trid_1) { + obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_BUFFER _tmp_1 = param.projection2(); + obsw_M001_1::TC_SET _tmp_2 = param.projection1(); - } else { - std::unordered_map<obsw_M001_1::_ProjectionRead_env_Receive_TC, obsw_M001_1::_ProjectionWrite_env_Receive_TC, obsw_M001_1::_ProjectionRead_env_Receive_TC::Hash, obsw_M001_1::_ProjectionRead_env_Receive_TC::HashEqual> _OpCache_with_parameter_env_Receive_TC = _OpCache_with_parameter_env_Receive_TC_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_env_Receive_TC.find(readState); - if(writeState_ptr != _OpCache_with_parameter_env_Receive_TC.end()) { - obsw_M001_1::_ProjectionWrite_env_Receive_TC writeState = writeState_ptr->second; - copiedState._apply_update_for_env_Receive_TC(writeState); - } else { - copiedState.env_Receive_TC(_tmp_2, _tmp_1); - obsw_M001_1::_ProjectionWrite_env_Receive_TC writeState = copiedState._update_for_env_Receive_TC(); - { - std::unique_lock<std::mutex> _ProjectionRead_env_Receive_TC_lock(_ProjectionRead_env_Receive_TC_mutex); - _OpCache_with_parameter_env_Receive_TC.insert({readState, writeState}); - } - } + obsw_M001_1 copiedState = state._copy(); + obsw_M001_1::_ProjectionRead_env_Receive_TC readState = state._projected_state_for_env_Receive_TC(); + + auto _OpCache_with_parameter_env_Receive_TC_ptr = _OpCache_env_Receive_TC.find(param); + if(_OpCache_with_parameter_env_Receive_TC_ptr == _OpCache_env_Receive_TC.end()) { + copiedState.env_Receive_TC(_tmp_2, _tmp_1); + obsw_M001_1::_ProjectionWrite_env_Receive_TC writeState = copiedState._update_for_env_Receive_TC(); + std::unordered_map<obsw_M001_1::_ProjectionRead_env_Receive_TC, obsw_M001_1::_ProjectionWrite_env_Receive_TC, obsw_M001_1::_ProjectionRead_env_Receive_TC::Hash, obsw_M001_1::_ProjectionRead_env_Receive_TC::HashEqual> _OpCache_with_parameter_env_Receive_TC; + _OpCache_with_parameter_env_Receive_TC.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_env_Receive_TC_lock(_ProjectionRead_env_Receive_TC_mutex); + _OpCache_env_Receive_TC.insert({param, _OpCache_with_parameter_env_Receive_TC}); } - copiedState.stateAccessedVia = "env_Receive_TC"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<BTuple<obsw_M001_1::TC_SET, obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_BUFFER >> _trid_1 = _trid_1_ptr->second; - for(const BTuple<obsw_M001_1::TC_SET, obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_BUFFER >& param : _trid_1) { - obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_BUFFER _tmp_1 = param.projection2(); - obsw_M001_1::TC_SET _tmp_2 = param.projection1(); - - obsw_M001_1 copiedState = state._copy(); - obsw_M001_1::_ProjectionRead_env_Receive_TC readState = state._projected_state_for_env_Receive_TC(); - - auto _OpCache_with_parameter_env_Receive_TC_ptr = _OpCache_env_Receive_TC.find(param); - if(_OpCache_with_parameter_env_Receive_TC_ptr == _OpCache_env_Receive_TC.end()) { + } else { + std::unordered_map<obsw_M001_1::_ProjectionRead_env_Receive_TC, obsw_M001_1::_ProjectionWrite_env_Receive_TC, obsw_M001_1::_ProjectionRead_env_Receive_TC::Hash, obsw_M001_1::_ProjectionRead_env_Receive_TC::HashEqual> _OpCache_with_parameter_env_Receive_TC = _OpCache_with_parameter_env_Receive_TC_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_env_Receive_TC.find(readState); + if(writeState_ptr != _OpCache_with_parameter_env_Receive_TC.end()) { + obsw_M001_1::_ProjectionWrite_env_Receive_TC writeState = writeState_ptr->second; + copiedState._apply_update_for_env_Receive_TC(writeState); + } else { copiedState.env_Receive_TC(_tmp_2, _tmp_1); obsw_M001_1::_ProjectionWrite_env_Receive_TC writeState = copiedState._update_for_env_Receive_TC(); - std::unordered_map<obsw_M001_1::_ProjectionRead_env_Receive_TC, obsw_M001_1::_ProjectionWrite_env_Receive_TC, obsw_M001_1::_ProjectionRead_env_Receive_TC::Hash, obsw_M001_1::_ProjectionRead_env_Receive_TC::HashEqual> _OpCache_with_parameter_env_Receive_TC; - _OpCache_with_parameter_env_Receive_TC.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_env_Receive_TC_lock(_ProjectionRead_env_Receive_TC_mutex); - _OpCache_env_Receive_TC.insert({param, _OpCache_with_parameter_env_Receive_TC}); - } - - } else { - std::unordered_map<obsw_M001_1::_ProjectionRead_env_Receive_TC, obsw_M001_1::_ProjectionWrite_env_Receive_TC, obsw_M001_1::_ProjectionRead_env_Receive_TC::Hash, obsw_M001_1::_ProjectionRead_env_Receive_TC::HashEqual> _OpCache_with_parameter_env_Receive_TC = _OpCache_with_parameter_env_Receive_TC_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_env_Receive_TC.find(readState); - if(writeState_ptr != _OpCache_with_parameter_env_Receive_TC.end()) { - obsw_M001_1::_ProjectionWrite_env_Receive_TC writeState = writeState_ptr->second; - copiedState._apply_update_for_env_Receive_TC(writeState); - } else { - copiedState.env_Receive_TC(_tmp_2, _tmp_1); - obsw_M001_1::_ProjectionWrite_env_Receive_TC writeState = copiedState._update_for_env_Receive_TC(); - { - std::unique_lock<std::mutex> _ProjectionRead_env_Receive_TC_lock(_ProjectionRead_env_Receive_TC_mutex); - _OpCache_with_parameter_env_Receive_TC.insert({readState, writeState}); - } + _OpCache_with_parameter_env_Receive_TC.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "env_Receive_TC"; - result.insert(copiedState); + copiedState.stateAccessedVia = "env_Receive_TC"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } obsw_M001_1::_ProjectionRead__tr_Poll_TC read__tr_Poll_TC_state = state._projected_state_for__tr_Poll_TC(); + BSet<BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_BUFFER >> _trid_2; auto _trid_2_ptr = _OpCache_tr_Poll_TC.find(read__tr_Poll_TC_state); if(_trid_2_ptr == _OpCache_tr_Poll_TC.end()) { - BSet<BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_BUFFER >> _trid_2 = state._tr_Poll_TC(); + _trid_2 = state._tr_Poll_TC(); { std::unique_lock<std::mutex> _ProjectionRead__tr_Poll_TC_lock(_ProjectionRead__tr_Poll_TC_mutex); _OpCache_tr_Poll_TC.insert({read__tr_Poll_TC_state, _trid_2}); } - for(const BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_BUFFER >& param : _trid_2) { - obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_BUFFER _tmp_1 = param.projection2(); - obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_2 = param.projection1(); - - obsw_M001_1 copiedState = state._copy(); - obsw_M001_1::_ProjectionRead_Poll_TC readState = state._projected_state_for_Poll_TC(); + } else { + _trid_2 = _trid_2_ptr->second; + } - auto _OpCache_with_parameter_Poll_TC_ptr = _OpCache_Poll_TC.find(param); - if(_OpCache_with_parameter_Poll_TC_ptr == _OpCache_Poll_TC.end()) { - copiedState.Poll_TC(_tmp_2, _tmp_1); - obsw_M001_1::_ProjectionWrite_Poll_TC writeState = copiedState._update_for_Poll_TC(); - std::unordered_map<obsw_M001_1::_ProjectionRead_Poll_TC, obsw_M001_1::_ProjectionWrite_Poll_TC, obsw_M001_1::_ProjectionRead_Poll_TC::Hash, obsw_M001_1::_ProjectionRead_Poll_TC::HashEqual> _OpCache_with_parameter_Poll_TC; - _OpCache_with_parameter_Poll_TC.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_Poll_TC_lock(_ProjectionRead_Poll_TC_mutex); - _OpCache_Poll_TC.insert({param, _OpCache_with_parameter_Poll_TC}); - } + for(const BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_BUFFER >& param : _trid_2) { + obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_BUFFER _tmp_1 = param.projection2(); + obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_2 = param.projection1(); - } else { - std::unordered_map<obsw_M001_1::_ProjectionRead_Poll_TC, obsw_M001_1::_ProjectionWrite_Poll_TC, obsw_M001_1::_ProjectionRead_Poll_TC::Hash, obsw_M001_1::_ProjectionRead_Poll_TC::HashEqual> _OpCache_with_parameter_Poll_TC = _OpCache_with_parameter_Poll_TC_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_Poll_TC.find(readState); - if(writeState_ptr != _OpCache_with_parameter_Poll_TC.end()) { - obsw_M001_1::_ProjectionWrite_Poll_TC writeState = writeState_ptr->second; - copiedState._apply_update_for_Poll_TC(writeState); - } else { - copiedState.Poll_TC(_tmp_2, _tmp_1); - obsw_M001_1::_ProjectionWrite_Poll_TC writeState = copiedState._update_for_Poll_TC(); - { - std::unique_lock<std::mutex> _ProjectionRead_Poll_TC_lock(_ProjectionRead_Poll_TC_mutex); - _OpCache_with_parameter_Poll_TC.insert({readState, writeState}); - } - } + obsw_M001_1 copiedState = state._copy(); + obsw_M001_1::_ProjectionRead_Poll_TC readState = state._projected_state_for_Poll_TC(); + + auto _OpCache_with_parameter_Poll_TC_ptr = _OpCache_Poll_TC.find(param); + if(_OpCache_with_parameter_Poll_TC_ptr == _OpCache_Poll_TC.end()) { + copiedState.Poll_TC(_tmp_2, _tmp_1); + obsw_M001_1::_ProjectionWrite_Poll_TC writeState = copiedState._update_for_Poll_TC(); + std::unordered_map<obsw_M001_1::_ProjectionRead_Poll_TC, obsw_M001_1::_ProjectionWrite_Poll_TC, obsw_M001_1::_ProjectionRead_Poll_TC::Hash, obsw_M001_1::_ProjectionRead_Poll_TC::HashEqual> _OpCache_with_parameter_Poll_TC; + _OpCache_with_parameter_Poll_TC.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_Poll_TC_lock(_ProjectionRead_Poll_TC_mutex); + _OpCache_Poll_TC.insert({param, _OpCache_with_parameter_Poll_TC}); } - copiedState.stateAccessedVia = "Poll_TC"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_BUFFER >> _trid_2 = _trid_2_ptr->second; - for(const BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_BUFFER >& param : _trid_2) { - obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_BUFFER _tmp_1 = param.projection2(); - obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_2 = param.projection1(); - - obsw_M001_1 copiedState = state._copy(); - obsw_M001_1::_ProjectionRead_Poll_TC readState = state._projected_state_for_Poll_TC(); - - auto _OpCache_with_parameter_Poll_TC_ptr = _OpCache_Poll_TC.find(param); - if(_OpCache_with_parameter_Poll_TC_ptr == _OpCache_Poll_TC.end()) { + } else { + std::unordered_map<obsw_M001_1::_ProjectionRead_Poll_TC, obsw_M001_1::_ProjectionWrite_Poll_TC, obsw_M001_1::_ProjectionRead_Poll_TC::Hash, obsw_M001_1::_ProjectionRead_Poll_TC::HashEqual> _OpCache_with_parameter_Poll_TC = _OpCache_with_parameter_Poll_TC_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_Poll_TC.find(readState); + if(writeState_ptr != _OpCache_with_parameter_Poll_TC.end()) { + obsw_M001_1::_ProjectionWrite_Poll_TC writeState = writeState_ptr->second; + copiedState._apply_update_for_Poll_TC(writeState); + } else { copiedState.Poll_TC(_tmp_2, _tmp_1); obsw_M001_1::_ProjectionWrite_Poll_TC writeState = copiedState._update_for_Poll_TC(); - std::unordered_map<obsw_M001_1::_ProjectionRead_Poll_TC, obsw_M001_1::_ProjectionWrite_Poll_TC, obsw_M001_1::_ProjectionRead_Poll_TC::Hash, obsw_M001_1::_ProjectionRead_Poll_TC::HashEqual> _OpCache_with_parameter_Poll_TC; - _OpCache_with_parameter_Poll_TC.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_Poll_TC_lock(_ProjectionRead_Poll_TC_mutex); - _OpCache_Poll_TC.insert({param, _OpCache_with_parameter_Poll_TC}); - } - - } else { - std::unordered_map<obsw_M001_1::_ProjectionRead_Poll_TC, obsw_M001_1::_ProjectionWrite_Poll_TC, obsw_M001_1::_ProjectionRead_Poll_TC::Hash, obsw_M001_1::_ProjectionRead_Poll_TC::HashEqual> _OpCache_with_parameter_Poll_TC = _OpCache_with_parameter_Poll_TC_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_Poll_TC.find(readState); - if(writeState_ptr != _OpCache_with_parameter_Poll_TC.end()) { - obsw_M001_1::_ProjectionWrite_Poll_TC writeState = writeState_ptr->second; - copiedState._apply_update_for_Poll_TC(writeState); - } else { - copiedState.Poll_TC(_tmp_2, _tmp_1); - obsw_M001_1::_ProjectionWrite_Poll_TC writeState = copiedState._update_for_Poll_TC(); - { - std::unique_lock<std::mutex> _ProjectionRead_Poll_TC_lock(_ProjectionRead_Poll_TC_mutex); - _OpCache_with_parameter_Poll_TC.insert({readState, writeState}); - } + _OpCache_with_parameter_Poll_TC.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "Poll_TC"; - result.insert(copiedState); + copiedState.stateAccessedVia = "Poll_TC"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } obsw_M001_1::_ProjectionRead__tr_Accept_TC read__tr_Accept_TC_state = state._projected_state_for__tr_Accept_TC(); + BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_3; auto _trid_3_ptr = _OpCache_tr_Accept_TC.find(read__tr_Accept_TC_state); if(_trid_3_ptr == _OpCache_tr_Accept_TC.end()) { - BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_3 = state._tr_Accept_TC(); + _trid_3 = state._tr_Accept_TC(); { std::unique_lock<std::mutex> _ProjectionRead__tr_Accept_TC_lock(_ProjectionRead__tr_Accept_TC_mutex); _OpCache_tr_Accept_TC.insert({read__tr_Accept_TC_state, _trid_3}); } - for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_3) { - obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param; - - obsw_M001_1 copiedState = state._copy(); - obsw_M001_1::_ProjectionRead_Accept_TC readState = state._projected_state_for_Accept_TC(); + } else { + _trid_3 = _trid_3_ptr->second; + } - auto _OpCache_with_parameter_Accept_TC_ptr = _OpCache_Accept_TC.find(param); - if(_OpCache_with_parameter_Accept_TC_ptr == _OpCache_Accept_TC.end()) { - copiedState.Accept_TC(_tmp_1); - obsw_M001_1::_ProjectionWrite_Accept_TC writeState = copiedState._update_for_Accept_TC(); - std::unordered_map<obsw_M001_1::_ProjectionRead_Accept_TC, obsw_M001_1::_ProjectionWrite_Accept_TC, obsw_M001_1::_ProjectionRead_Accept_TC::Hash, obsw_M001_1::_ProjectionRead_Accept_TC::HashEqual> _OpCache_with_parameter_Accept_TC; - _OpCache_with_parameter_Accept_TC.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_Accept_TC_lock(_ProjectionRead_Accept_TC_mutex); - _OpCache_Accept_TC.insert({param, _OpCache_with_parameter_Accept_TC}); - } + for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_3) { + obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param; - } else { - std::unordered_map<obsw_M001_1::_ProjectionRead_Accept_TC, obsw_M001_1::_ProjectionWrite_Accept_TC, obsw_M001_1::_ProjectionRead_Accept_TC::Hash, obsw_M001_1::_ProjectionRead_Accept_TC::HashEqual> _OpCache_with_parameter_Accept_TC = _OpCache_with_parameter_Accept_TC_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_Accept_TC.find(readState); - if(writeState_ptr != _OpCache_with_parameter_Accept_TC.end()) { - obsw_M001_1::_ProjectionWrite_Accept_TC writeState = writeState_ptr->second; - copiedState._apply_update_for_Accept_TC(writeState); - } else { - copiedState.Accept_TC(_tmp_1); - obsw_M001_1::_ProjectionWrite_Accept_TC writeState = copiedState._update_for_Accept_TC(); - { - std::unique_lock<std::mutex> _ProjectionRead_Accept_TC_lock(_ProjectionRead_Accept_TC_mutex); - _OpCache_with_parameter_Accept_TC.insert({readState, writeState}); - } - } + obsw_M001_1 copiedState = state._copy(); + obsw_M001_1::_ProjectionRead_Accept_TC readState = state._projected_state_for_Accept_TC(); + + auto _OpCache_with_parameter_Accept_TC_ptr = _OpCache_Accept_TC.find(param); + if(_OpCache_with_parameter_Accept_TC_ptr == _OpCache_Accept_TC.end()) { + copiedState.Accept_TC(_tmp_1); + obsw_M001_1::_ProjectionWrite_Accept_TC writeState = copiedState._update_for_Accept_TC(); + std::unordered_map<obsw_M001_1::_ProjectionRead_Accept_TC, obsw_M001_1::_ProjectionWrite_Accept_TC, obsw_M001_1::_ProjectionRead_Accept_TC::Hash, obsw_M001_1::_ProjectionRead_Accept_TC::HashEqual> _OpCache_with_parameter_Accept_TC; + _OpCache_with_parameter_Accept_TC.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_Accept_TC_lock(_ProjectionRead_Accept_TC_mutex); + _OpCache_Accept_TC.insert({param, _OpCache_with_parameter_Accept_TC}); } - copiedState.stateAccessedVia = "Accept_TC"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_3 = _trid_3_ptr->second; - for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_3) { - obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param; - - obsw_M001_1 copiedState = state._copy(); - obsw_M001_1::_ProjectionRead_Accept_TC readState = state._projected_state_for_Accept_TC(); - - auto _OpCache_with_parameter_Accept_TC_ptr = _OpCache_Accept_TC.find(param); - if(_OpCache_with_parameter_Accept_TC_ptr == _OpCache_Accept_TC.end()) { + } else { + std::unordered_map<obsw_M001_1::_ProjectionRead_Accept_TC, obsw_M001_1::_ProjectionWrite_Accept_TC, obsw_M001_1::_ProjectionRead_Accept_TC::Hash, obsw_M001_1::_ProjectionRead_Accept_TC::HashEqual> _OpCache_with_parameter_Accept_TC = _OpCache_with_parameter_Accept_TC_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_Accept_TC.find(readState); + if(writeState_ptr != _OpCache_with_parameter_Accept_TC.end()) { + obsw_M001_1::_ProjectionWrite_Accept_TC writeState = writeState_ptr->second; + copiedState._apply_update_for_Accept_TC(writeState); + } else { copiedState.Accept_TC(_tmp_1); obsw_M001_1::_ProjectionWrite_Accept_TC writeState = copiedState._update_for_Accept_TC(); - std::unordered_map<obsw_M001_1::_ProjectionRead_Accept_TC, obsw_M001_1::_ProjectionWrite_Accept_TC, obsw_M001_1::_ProjectionRead_Accept_TC::Hash, obsw_M001_1::_ProjectionRead_Accept_TC::HashEqual> _OpCache_with_parameter_Accept_TC; - _OpCache_with_parameter_Accept_TC.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_Accept_TC_lock(_ProjectionRead_Accept_TC_mutex); - _OpCache_Accept_TC.insert({param, _OpCache_with_parameter_Accept_TC}); - } - - } else { - std::unordered_map<obsw_M001_1::_ProjectionRead_Accept_TC, obsw_M001_1::_ProjectionWrite_Accept_TC, obsw_M001_1::_ProjectionRead_Accept_TC::Hash, obsw_M001_1::_ProjectionRead_Accept_TC::HashEqual> _OpCache_with_parameter_Accept_TC = _OpCache_with_parameter_Accept_TC_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_Accept_TC.find(readState); - if(writeState_ptr != _OpCache_with_parameter_Accept_TC.end()) { - obsw_M001_1::_ProjectionWrite_Accept_TC writeState = writeState_ptr->second; - copiedState._apply_update_for_Accept_TC(writeState); - } else { - copiedState.Accept_TC(_tmp_1); - obsw_M001_1::_ProjectionWrite_Accept_TC writeState = copiedState._update_for_Accept_TC(); - { - std::unique_lock<std::mutex> _ProjectionRead_Accept_TC_lock(_ProjectionRead_Accept_TC_mutex); - _OpCache_with_parameter_Accept_TC.insert({readState, writeState}); - } + _OpCache_with_parameter_Accept_TC.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "Accept_TC"; - result.insert(copiedState); + copiedState.stateAccessedVia = "Accept_TC"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } obsw_M001_1::_ProjectionRead__tr_Reject_TC read__tr_Reject_TC_state = state._projected_state_for__tr_Reject_TC(); + BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_4; auto _trid_4_ptr = _OpCache_tr_Reject_TC.find(read__tr_Reject_TC_state); if(_trid_4_ptr == _OpCache_tr_Reject_TC.end()) { - BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_4 = state._tr_Reject_TC(); + _trid_4 = state._tr_Reject_TC(); { std::unique_lock<std::mutex> _ProjectionRead__tr_Reject_TC_lock(_ProjectionRead__tr_Reject_TC_mutex); _OpCache_tr_Reject_TC.insert({read__tr_Reject_TC_state, _trid_4}); } - for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_4) { - obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param; - - obsw_M001_1 copiedState = state._copy(); - obsw_M001_1::_ProjectionRead_Reject_TC readState = state._projected_state_for_Reject_TC(); + } else { + _trid_4 = _trid_4_ptr->second; + } - auto _OpCache_with_parameter_Reject_TC_ptr = _OpCache_Reject_TC.find(param); - if(_OpCache_with_parameter_Reject_TC_ptr == _OpCache_Reject_TC.end()) { - copiedState.Reject_TC(_tmp_1); - obsw_M001_1::_ProjectionWrite_Reject_TC writeState = copiedState._update_for_Reject_TC(); - std::unordered_map<obsw_M001_1::_ProjectionRead_Reject_TC, obsw_M001_1::_ProjectionWrite_Reject_TC, obsw_M001_1::_ProjectionRead_Reject_TC::Hash, obsw_M001_1::_ProjectionRead_Reject_TC::HashEqual> _OpCache_with_parameter_Reject_TC; - _OpCache_with_parameter_Reject_TC.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_Reject_TC_lock(_ProjectionRead_Reject_TC_mutex); - _OpCache_Reject_TC.insert({param, _OpCache_with_parameter_Reject_TC}); - } + for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_4) { + obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param; - } else { - std::unordered_map<obsw_M001_1::_ProjectionRead_Reject_TC, obsw_M001_1::_ProjectionWrite_Reject_TC, obsw_M001_1::_ProjectionRead_Reject_TC::Hash, obsw_M001_1::_ProjectionRead_Reject_TC::HashEqual> _OpCache_with_parameter_Reject_TC = _OpCache_with_parameter_Reject_TC_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_Reject_TC.find(readState); - if(writeState_ptr != _OpCache_with_parameter_Reject_TC.end()) { - obsw_M001_1::_ProjectionWrite_Reject_TC writeState = writeState_ptr->second; - copiedState._apply_update_for_Reject_TC(writeState); - } else { - copiedState.Reject_TC(_tmp_1); - obsw_M001_1::_ProjectionWrite_Reject_TC writeState = copiedState._update_for_Reject_TC(); - { - std::unique_lock<std::mutex> _ProjectionRead_Reject_TC_lock(_ProjectionRead_Reject_TC_mutex); - _OpCache_with_parameter_Reject_TC.insert({readState, writeState}); - } - } + obsw_M001_1 copiedState = state._copy(); + obsw_M001_1::_ProjectionRead_Reject_TC readState = state._projected_state_for_Reject_TC(); + + auto _OpCache_with_parameter_Reject_TC_ptr = _OpCache_Reject_TC.find(param); + if(_OpCache_with_parameter_Reject_TC_ptr == _OpCache_Reject_TC.end()) { + copiedState.Reject_TC(_tmp_1); + obsw_M001_1::_ProjectionWrite_Reject_TC writeState = copiedState._update_for_Reject_TC(); + std::unordered_map<obsw_M001_1::_ProjectionRead_Reject_TC, obsw_M001_1::_ProjectionWrite_Reject_TC, obsw_M001_1::_ProjectionRead_Reject_TC::Hash, obsw_M001_1::_ProjectionRead_Reject_TC::HashEqual> _OpCache_with_parameter_Reject_TC; + _OpCache_with_parameter_Reject_TC.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_Reject_TC_lock(_ProjectionRead_Reject_TC_mutex); + _OpCache_Reject_TC.insert({param, _OpCache_with_parameter_Reject_TC}); } - copiedState.stateAccessedVia = "Reject_TC"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_4 = _trid_4_ptr->second; - for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_4) { - obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param; - - obsw_M001_1 copiedState = state._copy(); - obsw_M001_1::_ProjectionRead_Reject_TC readState = state._projected_state_for_Reject_TC(); - - auto _OpCache_with_parameter_Reject_TC_ptr = _OpCache_Reject_TC.find(param); - if(_OpCache_with_parameter_Reject_TC_ptr == _OpCache_Reject_TC.end()) { + } else { + std::unordered_map<obsw_M001_1::_ProjectionRead_Reject_TC, obsw_M001_1::_ProjectionWrite_Reject_TC, obsw_M001_1::_ProjectionRead_Reject_TC::Hash, obsw_M001_1::_ProjectionRead_Reject_TC::HashEqual> _OpCache_with_parameter_Reject_TC = _OpCache_with_parameter_Reject_TC_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_Reject_TC.find(readState); + if(writeState_ptr != _OpCache_with_parameter_Reject_TC.end()) { + obsw_M001_1::_ProjectionWrite_Reject_TC writeState = writeState_ptr->second; + copiedState._apply_update_for_Reject_TC(writeState); + } else { copiedState.Reject_TC(_tmp_1); obsw_M001_1::_ProjectionWrite_Reject_TC writeState = copiedState._update_for_Reject_TC(); - std::unordered_map<obsw_M001_1::_ProjectionRead_Reject_TC, obsw_M001_1::_ProjectionWrite_Reject_TC, obsw_M001_1::_ProjectionRead_Reject_TC::Hash, obsw_M001_1::_ProjectionRead_Reject_TC::HashEqual> _OpCache_with_parameter_Reject_TC; - _OpCache_with_parameter_Reject_TC.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_Reject_TC_lock(_ProjectionRead_Reject_TC_mutex); - _OpCache_Reject_TC.insert({param, _OpCache_with_parameter_Reject_TC}); - } - - } else { - std::unordered_map<obsw_M001_1::_ProjectionRead_Reject_TC, obsw_M001_1::_ProjectionWrite_Reject_TC, obsw_M001_1::_ProjectionRead_Reject_TC::Hash, obsw_M001_1::_ProjectionRead_Reject_TC::HashEqual> _OpCache_with_parameter_Reject_TC = _OpCache_with_parameter_Reject_TC_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_Reject_TC.find(readState); - if(writeState_ptr != _OpCache_with_parameter_Reject_TC.end()) { - obsw_M001_1::_ProjectionWrite_Reject_TC writeState = writeState_ptr->second; - copiedState._apply_update_for_Reject_TC(writeState); - } else { - copiedState.Reject_TC(_tmp_1); - obsw_M001_1::_ProjectionWrite_Reject_TC writeState = copiedState._update_for_Reject_TC(); - { - std::unique_lock<std::mutex> _ProjectionRead_Reject_TC_lock(_ProjectionRead_Reject_TC_mutex); - _OpCache_with_parameter_Reject_TC.insert({readState, writeState}); - } + _OpCache_with_parameter_Reject_TC.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "Reject_TC"; - result.insert(copiedState); + copiedState.stateAccessedVia = "Reject_TC"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } obsw_M001_1::_ProjectionRead__tr_Report_TC_Acceptance read__tr_Report_TC_Acceptance_state = state._projected_state_for__tr_Report_TC_Acceptance(); + BSet<BTuple<BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::TM_SET >, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL >> _trid_5; auto _trid_5_ptr = _OpCache_tr_Report_TC_Acceptance.find(read__tr_Report_TC_Acceptance_state); if(_trid_5_ptr == _OpCache_tr_Report_TC_Acceptance.end()) { - BSet<BTuple<BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::TM_SET >, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL >> _trid_5 = state._tr_Report_TC_Acceptance(); + _trid_5 = state._tr_Report_TC_Acceptance(); { std::unique_lock<std::mutex> _ProjectionRead__tr_Report_TC_Acceptance_lock(_ProjectionRead__tr_Report_TC_Acceptance_mutex); _OpCache_tr_Report_TC_Acceptance.insert({read__tr_Report_TC_Acceptance_state, _trid_5}); } - for(const BTuple<BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::TM_SET >, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL >& param : _trid_5) { - obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_1 = param.projection2(); - BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::TM_SET > _tmp_2 = param.projection1(); - obsw_M001_1::TM_SET _tmp_3 = _tmp_2.projection2(); - obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_4 = _tmp_2.projection1(); - - obsw_M001_1 copiedState = state._copy(); - obsw_M001_1::_ProjectionRead_Report_TC_Acceptance readState = state._projected_state_for_Report_TC_Acceptance(); + } else { + _trid_5 = _trid_5_ptr->second; + } - auto _OpCache_with_parameter_Report_TC_Acceptance_ptr = _OpCache_Report_TC_Acceptance.find(param); - if(_OpCache_with_parameter_Report_TC_Acceptance_ptr == _OpCache_Report_TC_Acceptance.end()) { - copiedState.Report_TC_Acceptance(_tmp_4, _tmp_3, _tmp_1); - obsw_M001_1::_ProjectionWrite_Report_TC_Acceptance writeState = copiedState._update_for_Report_TC_Acceptance(); - std::unordered_map<obsw_M001_1::_ProjectionRead_Report_TC_Acceptance, obsw_M001_1::_ProjectionWrite_Report_TC_Acceptance, obsw_M001_1::_ProjectionRead_Report_TC_Acceptance::Hash, obsw_M001_1::_ProjectionRead_Report_TC_Acceptance::HashEqual> _OpCache_with_parameter_Report_TC_Acceptance; - _OpCache_with_parameter_Report_TC_Acceptance.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_Report_TC_Acceptance_lock(_ProjectionRead_Report_TC_Acceptance_mutex); - _OpCache_Report_TC_Acceptance.insert({param, _OpCache_with_parameter_Report_TC_Acceptance}); - } + for(const BTuple<BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::TM_SET >, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL >& param : _trid_5) { + obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_1 = param.projection2(); + BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::TM_SET > _tmp_2 = param.projection1(); + obsw_M001_1::TM_SET _tmp_3 = _tmp_2.projection2(); + obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_4 = _tmp_2.projection1(); - } else { - std::unordered_map<obsw_M001_1::_ProjectionRead_Report_TC_Acceptance, obsw_M001_1::_ProjectionWrite_Report_TC_Acceptance, obsw_M001_1::_ProjectionRead_Report_TC_Acceptance::Hash, obsw_M001_1::_ProjectionRead_Report_TC_Acceptance::HashEqual> _OpCache_with_parameter_Report_TC_Acceptance = _OpCache_with_parameter_Report_TC_Acceptance_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_Report_TC_Acceptance.find(readState); - if(writeState_ptr != _OpCache_with_parameter_Report_TC_Acceptance.end()) { - obsw_M001_1::_ProjectionWrite_Report_TC_Acceptance writeState = writeState_ptr->second; - copiedState._apply_update_for_Report_TC_Acceptance(writeState); - } else { - copiedState.Report_TC_Acceptance(_tmp_4, _tmp_3, _tmp_1); - obsw_M001_1::_ProjectionWrite_Report_TC_Acceptance writeState = copiedState._update_for_Report_TC_Acceptance(); - { - std::unique_lock<std::mutex> _ProjectionRead_Report_TC_Acceptance_lock(_ProjectionRead_Report_TC_Acceptance_mutex); - _OpCache_with_parameter_Report_TC_Acceptance.insert({readState, writeState}); - } - } + obsw_M001_1 copiedState = state._copy(); + obsw_M001_1::_ProjectionRead_Report_TC_Acceptance readState = state._projected_state_for_Report_TC_Acceptance(); + + auto _OpCache_with_parameter_Report_TC_Acceptance_ptr = _OpCache_Report_TC_Acceptance.find(param); + if(_OpCache_with_parameter_Report_TC_Acceptance_ptr == _OpCache_Report_TC_Acceptance.end()) { + copiedState.Report_TC_Acceptance(_tmp_4, _tmp_3, _tmp_1); + obsw_M001_1::_ProjectionWrite_Report_TC_Acceptance writeState = copiedState._update_for_Report_TC_Acceptance(); + std::unordered_map<obsw_M001_1::_ProjectionRead_Report_TC_Acceptance, obsw_M001_1::_ProjectionWrite_Report_TC_Acceptance, obsw_M001_1::_ProjectionRead_Report_TC_Acceptance::Hash, obsw_M001_1::_ProjectionRead_Report_TC_Acceptance::HashEqual> _OpCache_with_parameter_Report_TC_Acceptance; + _OpCache_with_parameter_Report_TC_Acceptance.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_Report_TC_Acceptance_lock(_ProjectionRead_Report_TC_Acceptance_mutex); + _OpCache_Report_TC_Acceptance.insert({param, _OpCache_with_parameter_Report_TC_Acceptance}); } - copiedState.stateAccessedVia = "Report_TC_Acceptance"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<BTuple<BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::TM_SET >, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL >> _trid_5 = _trid_5_ptr->second; - for(const BTuple<BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::TM_SET >, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL >& param : _trid_5) { - obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_1 = param.projection2(); - BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::TM_SET > _tmp_2 = param.projection1(); - obsw_M001_1::TM_SET _tmp_3 = _tmp_2.projection2(); - obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_4 = _tmp_2.projection1(); - - obsw_M001_1 copiedState = state._copy(); - obsw_M001_1::_ProjectionRead_Report_TC_Acceptance readState = state._projected_state_for_Report_TC_Acceptance(); - - auto _OpCache_with_parameter_Report_TC_Acceptance_ptr = _OpCache_Report_TC_Acceptance.find(param); - if(_OpCache_with_parameter_Report_TC_Acceptance_ptr == _OpCache_Report_TC_Acceptance.end()) { + } else { + std::unordered_map<obsw_M001_1::_ProjectionRead_Report_TC_Acceptance, obsw_M001_1::_ProjectionWrite_Report_TC_Acceptance, obsw_M001_1::_ProjectionRead_Report_TC_Acceptance::Hash, obsw_M001_1::_ProjectionRead_Report_TC_Acceptance::HashEqual> _OpCache_with_parameter_Report_TC_Acceptance = _OpCache_with_parameter_Report_TC_Acceptance_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_Report_TC_Acceptance.find(readState); + if(writeState_ptr != _OpCache_with_parameter_Report_TC_Acceptance.end()) { + obsw_M001_1::_ProjectionWrite_Report_TC_Acceptance writeState = writeState_ptr->second; + copiedState._apply_update_for_Report_TC_Acceptance(writeState); + } else { copiedState.Report_TC_Acceptance(_tmp_4, _tmp_3, _tmp_1); obsw_M001_1::_ProjectionWrite_Report_TC_Acceptance writeState = copiedState._update_for_Report_TC_Acceptance(); - std::unordered_map<obsw_M001_1::_ProjectionRead_Report_TC_Acceptance, obsw_M001_1::_ProjectionWrite_Report_TC_Acceptance, obsw_M001_1::_ProjectionRead_Report_TC_Acceptance::Hash, obsw_M001_1::_ProjectionRead_Report_TC_Acceptance::HashEqual> _OpCache_with_parameter_Report_TC_Acceptance; - _OpCache_with_parameter_Report_TC_Acceptance.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_Report_TC_Acceptance_lock(_ProjectionRead_Report_TC_Acceptance_mutex); - _OpCache_Report_TC_Acceptance.insert({param, _OpCache_with_parameter_Report_TC_Acceptance}); - } - - } else { - std::unordered_map<obsw_M001_1::_ProjectionRead_Report_TC_Acceptance, obsw_M001_1::_ProjectionWrite_Report_TC_Acceptance, obsw_M001_1::_ProjectionRead_Report_TC_Acceptance::Hash, obsw_M001_1::_ProjectionRead_Report_TC_Acceptance::HashEqual> _OpCache_with_parameter_Report_TC_Acceptance = _OpCache_with_parameter_Report_TC_Acceptance_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_Report_TC_Acceptance.find(readState); - if(writeState_ptr != _OpCache_with_parameter_Report_TC_Acceptance.end()) { - obsw_M001_1::_ProjectionWrite_Report_TC_Acceptance writeState = writeState_ptr->second; - copiedState._apply_update_for_Report_TC_Acceptance(writeState); - } else { - copiedState.Report_TC_Acceptance(_tmp_4, _tmp_3, _tmp_1); - obsw_M001_1::_ProjectionWrite_Report_TC_Acceptance writeState = copiedState._update_for_Report_TC_Acceptance(); - { - std::unique_lock<std::mutex> _ProjectionRead_Report_TC_Acceptance_lock(_ProjectionRead_Report_TC_Acceptance_mutex); - _OpCache_with_parameter_Report_TC_Acceptance.insert({readState, writeState}); - } + _OpCache_with_parameter_Report_TC_Acceptance.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "Report_TC_Acceptance"; - result.insert(copiedState); + copiedState.stateAccessedVia = "Report_TC_Acceptance"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } obsw_M001_1::_ProjectionRead__tr_Skip_TC_Acceptance_Report read__tr_Skip_TC_Acceptance_Report_state = state._projected_state_for__tr_Skip_TC_Acceptance_Report(); + BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_6; auto _trid_6_ptr = _OpCache_tr_Skip_TC_Acceptance_Report.find(read__tr_Skip_TC_Acceptance_Report_state); if(_trid_6_ptr == _OpCache_tr_Skip_TC_Acceptance_Report.end()) { - BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_6 = state._tr_Skip_TC_Acceptance_Report(); + _trid_6 = state._tr_Skip_TC_Acceptance_Report(); { std::unique_lock<std::mutex> _ProjectionRead__tr_Skip_TC_Acceptance_Report_lock(_ProjectionRead__tr_Skip_TC_Acceptance_Report_mutex); _OpCache_tr_Skip_TC_Acceptance_Report.insert({read__tr_Skip_TC_Acceptance_Report_state, _trid_6}); } - for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_6) { - obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param; - - obsw_M001_1 copiedState = state._copy(); - obsw_M001_1::_ProjectionRead_Skip_TC_Acceptance_Report readState = state._projected_state_for_Skip_TC_Acceptance_Report(); + } else { + _trid_6 = _trid_6_ptr->second; + } - auto _OpCache_with_parameter_Skip_TC_Acceptance_Report_ptr = _OpCache_Skip_TC_Acceptance_Report.find(param); - if(_OpCache_with_parameter_Skip_TC_Acceptance_Report_ptr == _OpCache_Skip_TC_Acceptance_Report.end()) { - copiedState.Skip_TC_Acceptance_Report(_tmp_1); - obsw_M001_1::_ProjectionWrite_Skip_TC_Acceptance_Report writeState = copiedState._update_for_Skip_TC_Acceptance_Report(); - std::unordered_map<obsw_M001_1::_ProjectionRead_Skip_TC_Acceptance_Report, obsw_M001_1::_ProjectionWrite_Skip_TC_Acceptance_Report, obsw_M001_1::_ProjectionRead_Skip_TC_Acceptance_Report::Hash, obsw_M001_1::_ProjectionRead_Skip_TC_Acceptance_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Acceptance_Report; - _OpCache_with_parameter_Skip_TC_Acceptance_Report.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_Skip_TC_Acceptance_Report_lock(_ProjectionRead_Skip_TC_Acceptance_Report_mutex); - _OpCache_Skip_TC_Acceptance_Report.insert({param, _OpCache_with_parameter_Skip_TC_Acceptance_Report}); - } + for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_6) { + obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param; - } else { - std::unordered_map<obsw_M001_1::_ProjectionRead_Skip_TC_Acceptance_Report, obsw_M001_1::_ProjectionWrite_Skip_TC_Acceptance_Report, obsw_M001_1::_ProjectionRead_Skip_TC_Acceptance_Report::Hash, obsw_M001_1::_ProjectionRead_Skip_TC_Acceptance_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Acceptance_Report = _OpCache_with_parameter_Skip_TC_Acceptance_Report_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_Skip_TC_Acceptance_Report.find(readState); - if(writeState_ptr != _OpCache_with_parameter_Skip_TC_Acceptance_Report.end()) { - obsw_M001_1::_ProjectionWrite_Skip_TC_Acceptance_Report writeState = writeState_ptr->second; - copiedState._apply_update_for_Skip_TC_Acceptance_Report(writeState); - } else { - copiedState.Skip_TC_Acceptance_Report(_tmp_1); - obsw_M001_1::_ProjectionWrite_Skip_TC_Acceptance_Report writeState = copiedState._update_for_Skip_TC_Acceptance_Report(); - { - std::unique_lock<std::mutex> _ProjectionRead_Skip_TC_Acceptance_Report_lock(_ProjectionRead_Skip_TC_Acceptance_Report_mutex); - _OpCache_with_parameter_Skip_TC_Acceptance_Report.insert({readState, writeState}); - } - } + obsw_M001_1 copiedState = state._copy(); + obsw_M001_1::_ProjectionRead_Skip_TC_Acceptance_Report readState = state._projected_state_for_Skip_TC_Acceptance_Report(); + + auto _OpCache_with_parameter_Skip_TC_Acceptance_Report_ptr = _OpCache_Skip_TC_Acceptance_Report.find(param); + if(_OpCache_with_parameter_Skip_TC_Acceptance_Report_ptr == _OpCache_Skip_TC_Acceptance_Report.end()) { + copiedState.Skip_TC_Acceptance_Report(_tmp_1); + obsw_M001_1::_ProjectionWrite_Skip_TC_Acceptance_Report writeState = copiedState._update_for_Skip_TC_Acceptance_Report(); + std::unordered_map<obsw_M001_1::_ProjectionRead_Skip_TC_Acceptance_Report, obsw_M001_1::_ProjectionWrite_Skip_TC_Acceptance_Report, obsw_M001_1::_ProjectionRead_Skip_TC_Acceptance_Report::Hash, obsw_M001_1::_ProjectionRead_Skip_TC_Acceptance_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Acceptance_Report; + _OpCache_with_parameter_Skip_TC_Acceptance_Report.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_Skip_TC_Acceptance_Report_lock(_ProjectionRead_Skip_TC_Acceptance_Report_mutex); + _OpCache_Skip_TC_Acceptance_Report.insert({param, _OpCache_with_parameter_Skip_TC_Acceptance_Report}); } - copiedState.stateAccessedVia = "Skip_TC_Acceptance_Report"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_6 = _trid_6_ptr->second; - for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_6) { - obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param; - - obsw_M001_1 copiedState = state._copy(); - obsw_M001_1::_ProjectionRead_Skip_TC_Acceptance_Report readState = state._projected_state_for_Skip_TC_Acceptance_Report(); - - auto _OpCache_with_parameter_Skip_TC_Acceptance_Report_ptr = _OpCache_Skip_TC_Acceptance_Report.find(param); - if(_OpCache_with_parameter_Skip_TC_Acceptance_Report_ptr == _OpCache_Skip_TC_Acceptance_Report.end()) { + } else { + std::unordered_map<obsw_M001_1::_ProjectionRead_Skip_TC_Acceptance_Report, obsw_M001_1::_ProjectionWrite_Skip_TC_Acceptance_Report, obsw_M001_1::_ProjectionRead_Skip_TC_Acceptance_Report::Hash, obsw_M001_1::_ProjectionRead_Skip_TC_Acceptance_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Acceptance_Report = _OpCache_with_parameter_Skip_TC_Acceptance_Report_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_Skip_TC_Acceptance_Report.find(readState); + if(writeState_ptr != _OpCache_with_parameter_Skip_TC_Acceptance_Report.end()) { + obsw_M001_1::_ProjectionWrite_Skip_TC_Acceptance_Report writeState = writeState_ptr->second; + copiedState._apply_update_for_Skip_TC_Acceptance_Report(writeState); + } else { copiedState.Skip_TC_Acceptance_Report(_tmp_1); obsw_M001_1::_ProjectionWrite_Skip_TC_Acceptance_Report writeState = copiedState._update_for_Skip_TC_Acceptance_Report(); - std::unordered_map<obsw_M001_1::_ProjectionRead_Skip_TC_Acceptance_Report, obsw_M001_1::_ProjectionWrite_Skip_TC_Acceptance_Report, obsw_M001_1::_ProjectionRead_Skip_TC_Acceptance_Report::Hash, obsw_M001_1::_ProjectionRead_Skip_TC_Acceptance_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Acceptance_Report; - _OpCache_with_parameter_Skip_TC_Acceptance_Report.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_Skip_TC_Acceptance_Report_lock(_ProjectionRead_Skip_TC_Acceptance_Report_mutex); - _OpCache_Skip_TC_Acceptance_Report.insert({param, _OpCache_with_parameter_Skip_TC_Acceptance_Report}); - } - - } else { - std::unordered_map<obsw_M001_1::_ProjectionRead_Skip_TC_Acceptance_Report, obsw_M001_1::_ProjectionWrite_Skip_TC_Acceptance_Report, obsw_M001_1::_ProjectionRead_Skip_TC_Acceptance_Report::Hash, obsw_M001_1::_ProjectionRead_Skip_TC_Acceptance_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Acceptance_Report = _OpCache_with_parameter_Skip_TC_Acceptance_Report_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_Skip_TC_Acceptance_Report.find(readState); - if(writeState_ptr != _OpCache_with_parameter_Skip_TC_Acceptance_Report.end()) { - obsw_M001_1::_ProjectionWrite_Skip_TC_Acceptance_Report writeState = writeState_ptr->second; - copiedState._apply_update_for_Skip_TC_Acceptance_Report(writeState); - } else { - copiedState.Skip_TC_Acceptance_Report(_tmp_1); - obsw_M001_1::_ProjectionWrite_Skip_TC_Acceptance_Report writeState = copiedState._update_for_Skip_TC_Acceptance_Report(); - { - std::unique_lock<std::mutex> _ProjectionRead_Skip_TC_Acceptance_Report_lock(_ProjectionRead_Skip_TC_Acceptance_Report_mutex); - _OpCache_with_parameter_Skip_TC_Acceptance_Report.insert({readState, writeState}); - } + _OpCache_with_parameter_Skip_TC_Acceptance_Report.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "Skip_TC_Acceptance_Report"; - result.insert(copiedState); + copiedState.stateAccessedVia = "Skip_TC_Acceptance_Report"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } obsw_M001_1::_ProjectionRead__tr_Report_TC_Rejection read__tr_Report_TC_Rejection_state = state._projected_state_for__tr_Report_TC_Rejection(); + BSet<BTuple<BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::TM_SET >, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL >> _trid_7; auto _trid_7_ptr = _OpCache_tr_Report_TC_Rejection.find(read__tr_Report_TC_Rejection_state); if(_trid_7_ptr == _OpCache_tr_Report_TC_Rejection.end()) { - BSet<BTuple<BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::TM_SET >, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL >> _trid_7 = state._tr_Report_TC_Rejection(); + _trid_7 = state._tr_Report_TC_Rejection(); { std::unique_lock<std::mutex> _ProjectionRead__tr_Report_TC_Rejection_lock(_ProjectionRead__tr_Report_TC_Rejection_mutex); _OpCache_tr_Report_TC_Rejection.insert({read__tr_Report_TC_Rejection_state, _trid_7}); } - for(const BTuple<BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::TM_SET >, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL >& param : _trid_7) { - obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_1 = param.projection2(); - BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::TM_SET > _tmp_2 = param.projection1(); - obsw_M001_1::TM_SET _tmp_3 = _tmp_2.projection2(); - obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_4 = _tmp_2.projection1(); - - obsw_M001_1 copiedState = state._copy(); - obsw_M001_1::_ProjectionRead_Report_TC_Rejection readState = state._projected_state_for_Report_TC_Rejection(); + } else { + _trid_7 = _trid_7_ptr->second; + } - auto _OpCache_with_parameter_Report_TC_Rejection_ptr = _OpCache_Report_TC_Rejection.find(param); - if(_OpCache_with_parameter_Report_TC_Rejection_ptr == _OpCache_Report_TC_Rejection.end()) { - copiedState.Report_TC_Rejection(_tmp_4, _tmp_3, _tmp_1); - obsw_M001_1::_ProjectionWrite_Report_TC_Rejection writeState = copiedState._update_for_Report_TC_Rejection(); - std::unordered_map<obsw_M001_1::_ProjectionRead_Report_TC_Rejection, obsw_M001_1::_ProjectionWrite_Report_TC_Rejection, obsw_M001_1::_ProjectionRead_Report_TC_Rejection::Hash, obsw_M001_1::_ProjectionRead_Report_TC_Rejection::HashEqual> _OpCache_with_parameter_Report_TC_Rejection; - _OpCache_with_parameter_Report_TC_Rejection.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_Report_TC_Rejection_lock(_ProjectionRead_Report_TC_Rejection_mutex); - _OpCache_Report_TC_Rejection.insert({param, _OpCache_with_parameter_Report_TC_Rejection}); - } + for(const BTuple<BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::TM_SET >, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL >& param : _trid_7) { + obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_1 = param.projection2(); + BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::TM_SET > _tmp_2 = param.projection1(); + obsw_M001_1::TM_SET _tmp_3 = _tmp_2.projection2(); + obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_4 = _tmp_2.projection1(); - } else { - std::unordered_map<obsw_M001_1::_ProjectionRead_Report_TC_Rejection, obsw_M001_1::_ProjectionWrite_Report_TC_Rejection, obsw_M001_1::_ProjectionRead_Report_TC_Rejection::Hash, obsw_M001_1::_ProjectionRead_Report_TC_Rejection::HashEqual> _OpCache_with_parameter_Report_TC_Rejection = _OpCache_with_parameter_Report_TC_Rejection_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_Report_TC_Rejection.find(readState); - if(writeState_ptr != _OpCache_with_parameter_Report_TC_Rejection.end()) { - obsw_M001_1::_ProjectionWrite_Report_TC_Rejection writeState = writeState_ptr->second; - copiedState._apply_update_for_Report_TC_Rejection(writeState); - } else { - copiedState.Report_TC_Rejection(_tmp_4, _tmp_3, _tmp_1); - obsw_M001_1::_ProjectionWrite_Report_TC_Rejection writeState = copiedState._update_for_Report_TC_Rejection(); - { - std::unique_lock<std::mutex> _ProjectionRead_Report_TC_Rejection_lock(_ProjectionRead_Report_TC_Rejection_mutex); - _OpCache_with_parameter_Report_TC_Rejection.insert({readState, writeState}); - } - } + obsw_M001_1 copiedState = state._copy(); + obsw_M001_1::_ProjectionRead_Report_TC_Rejection readState = state._projected_state_for_Report_TC_Rejection(); + + auto _OpCache_with_parameter_Report_TC_Rejection_ptr = _OpCache_Report_TC_Rejection.find(param); + if(_OpCache_with_parameter_Report_TC_Rejection_ptr == _OpCache_Report_TC_Rejection.end()) { + copiedState.Report_TC_Rejection(_tmp_4, _tmp_3, _tmp_1); + obsw_M001_1::_ProjectionWrite_Report_TC_Rejection writeState = copiedState._update_for_Report_TC_Rejection(); + std::unordered_map<obsw_M001_1::_ProjectionRead_Report_TC_Rejection, obsw_M001_1::_ProjectionWrite_Report_TC_Rejection, obsw_M001_1::_ProjectionRead_Report_TC_Rejection::Hash, obsw_M001_1::_ProjectionRead_Report_TC_Rejection::HashEqual> _OpCache_with_parameter_Report_TC_Rejection; + _OpCache_with_parameter_Report_TC_Rejection.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_Report_TC_Rejection_lock(_ProjectionRead_Report_TC_Rejection_mutex); + _OpCache_Report_TC_Rejection.insert({param, _OpCache_with_parameter_Report_TC_Rejection}); } - copiedState.stateAccessedVia = "Report_TC_Rejection"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<BTuple<BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::TM_SET >, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL >> _trid_7 = _trid_7_ptr->second; - for(const BTuple<BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::TM_SET >, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL >& param : _trid_7) { - obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_1 = param.projection2(); - BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::TM_SET > _tmp_2 = param.projection1(); - obsw_M001_1::TM_SET _tmp_3 = _tmp_2.projection2(); - obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_4 = _tmp_2.projection1(); - - obsw_M001_1 copiedState = state._copy(); - obsw_M001_1::_ProjectionRead_Report_TC_Rejection readState = state._projected_state_for_Report_TC_Rejection(); - - auto _OpCache_with_parameter_Report_TC_Rejection_ptr = _OpCache_Report_TC_Rejection.find(param); - if(_OpCache_with_parameter_Report_TC_Rejection_ptr == _OpCache_Report_TC_Rejection.end()) { + } else { + std::unordered_map<obsw_M001_1::_ProjectionRead_Report_TC_Rejection, obsw_M001_1::_ProjectionWrite_Report_TC_Rejection, obsw_M001_1::_ProjectionRead_Report_TC_Rejection::Hash, obsw_M001_1::_ProjectionRead_Report_TC_Rejection::HashEqual> _OpCache_with_parameter_Report_TC_Rejection = _OpCache_with_parameter_Report_TC_Rejection_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_Report_TC_Rejection.find(readState); + if(writeState_ptr != _OpCache_with_parameter_Report_TC_Rejection.end()) { + obsw_M001_1::_ProjectionWrite_Report_TC_Rejection writeState = writeState_ptr->second; + copiedState._apply_update_for_Report_TC_Rejection(writeState); + } else { copiedState.Report_TC_Rejection(_tmp_4, _tmp_3, _tmp_1); obsw_M001_1::_ProjectionWrite_Report_TC_Rejection writeState = copiedState._update_for_Report_TC_Rejection(); - std::unordered_map<obsw_M001_1::_ProjectionRead_Report_TC_Rejection, obsw_M001_1::_ProjectionWrite_Report_TC_Rejection, obsw_M001_1::_ProjectionRead_Report_TC_Rejection::Hash, obsw_M001_1::_ProjectionRead_Report_TC_Rejection::HashEqual> _OpCache_with_parameter_Report_TC_Rejection; - _OpCache_with_parameter_Report_TC_Rejection.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_Report_TC_Rejection_lock(_ProjectionRead_Report_TC_Rejection_mutex); - _OpCache_Report_TC_Rejection.insert({param, _OpCache_with_parameter_Report_TC_Rejection}); - } - - } else { - std::unordered_map<obsw_M001_1::_ProjectionRead_Report_TC_Rejection, obsw_M001_1::_ProjectionWrite_Report_TC_Rejection, obsw_M001_1::_ProjectionRead_Report_TC_Rejection::Hash, obsw_M001_1::_ProjectionRead_Report_TC_Rejection::HashEqual> _OpCache_with_parameter_Report_TC_Rejection = _OpCache_with_parameter_Report_TC_Rejection_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_Report_TC_Rejection.find(readState); - if(writeState_ptr != _OpCache_with_parameter_Report_TC_Rejection.end()) { - obsw_M001_1::_ProjectionWrite_Report_TC_Rejection writeState = writeState_ptr->second; - copiedState._apply_update_for_Report_TC_Rejection(writeState); - } else { - copiedState.Report_TC_Rejection(_tmp_4, _tmp_3, _tmp_1); - obsw_M001_1::_ProjectionWrite_Report_TC_Rejection writeState = copiedState._update_for_Report_TC_Rejection(); - { - std::unique_lock<std::mutex> _ProjectionRead_Report_TC_Rejection_lock(_ProjectionRead_Report_TC_Rejection_mutex); - _OpCache_with_parameter_Report_TC_Rejection.insert({readState, writeState}); - } + _OpCache_with_parameter_Report_TC_Rejection.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "Report_TC_Rejection"; - result.insert(copiedState); + copiedState.stateAccessedVia = "Report_TC_Rejection"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } obsw_M001_1::_ProjectionRead__tr_Skip_TC_Rejection_Report read__tr_Skip_TC_Rejection_Report_state = state._projected_state_for__tr_Skip_TC_Rejection_Report(); + BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_8; auto _trid_8_ptr = _OpCache_tr_Skip_TC_Rejection_Report.find(read__tr_Skip_TC_Rejection_Report_state); if(_trid_8_ptr == _OpCache_tr_Skip_TC_Rejection_Report.end()) { - BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_8 = state._tr_Skip_TC_Rejection_Report(); + _trid_8 = state._tr_Skip_TC_Rejection_Report(); { std::unique_lock<std::mutex> _ProjectionRead__tr_Skip_TC_Rejection_Report_lock(_ProjectionRead__tr_Skip_TC_Rejection_Report_mutex); _OpCache_tr_Skip_TC_Rejection_Report.insert({read__tr_Skip_TC_Rejection_Report_state, _trid_8}); } - for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_8) { - obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param; - - obsw_M001_1 copiedState = state._copy(); - obsw_M001_1::_ProjectionRead_Skip_TC_Rejection_Report readState = state._projected_state_for_Skip_TC_Rejection_Report(); + } else { + _trid_8 = _trid_8_ptr->second; + } - auto _OpCache_with_parameter_Skip_TC_Rejection_Report_ptr = _OpCache_Skip_TC_Rejection_Report.find(param); - if(_OpCache_with_parameter_Skip_TC_Rejection_Report_ptr == _OpCache_Skip_TC_Rejection_Report.end()) { - copiedState.Skip_TC_Rejection_Report(_tmp_1); - obsw_M001_1::_ProjectionWrite_Skip_TC_Rejection_Report writeState = copiedState._update_for_Skip_TC_Rejection_Report(); - std::unordered_map<obsw_M001_1::_ProjectionRead_Skip_TC_Rejection_Report, obsw_M001_1::_ProjectionWrite_Skip_TC_Rejection_Report, obsw_M001_1::_ProjectionRead_Skip_TC_Rejection_Report::Hash, obsw_M001_1::_ProjectionRead_Skip_TC_Rejection_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Rejection_Report; - _OpCache_with_parameter_Skip_TC_Rejection_Report.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_Skip_TC_Rejection_Report_lock(_ProjectionRead_Skip_TC_Rejection_Report_mutex); - _OpCache_Skip_TC_Rejection_Report.insert({param, _OpCache_with_parameter_Skip_TC_Rejection_Report}); - } + for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_8) { + obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param; - } else { - std::unordered_map<obsw_M001_1::_ProjectionRead_Skip_TC_Rejection_Report, obsw_M001_1::_ProjectionWrite_Skip_TC_Rejection_Report, obsw_M001_1::_ProjectionRead_Skip_TC_Rejection_Report::Hash, obsw_M001_1::_ProjectionRead_Skip_TC_Rejection_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Rejection_Report = _OpCache_with_parameter_Skip_TC_Rejection_Report_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_Skip_TC_Rejection_Report.find(readState); - if(writeState_ptr != _OpCache_with_parameter_Skip_TC_Rejection_Report.end()) { - obsw_M001_1::_ProjectionWrite_Skip_TC_Rejection_Report writeState = writeState_ptr->second; - copiedState._apply_update_for_Skip_TC_Rejection_Report(writeState); - } else { - copiedState.Skip_TC_Rejection_Report(_tmp_1); - obsw_M001_1::_ProjectionWrite_Skip_TC_Rejection_Report writeState = copiedState._update_for_Skip_TC_Rejection_Report(); - { - std::unique_lock<std::mutex> _ProjectionRead_Skip_TC_Rejection_Report_lock(_ProjectionRead_Skip_TC_Rejection_Report_mutex); - _OpCache_with_parameter_Skip_TC_Rejection_Report.insert({readState, writeState}); - } - } + obsw_M001_1 copiedState = state._copy(); + obsw_M001_1::_ProjectionRead_Skip_TC_Rejection_Report readState = state._projected_state_for_Skip_TC_Rejection_Report(); + + auto _OpCache_with_parameter_Skip_TC_Rejection_Report_ptr = _OpCache_Skip_TC_Rejection_Report.find(param); + if(_OpCache_with_parameter_Skip_TC_Rejection_Report_ptr == _OpCache_Skip_TC_Rejection_Report.end()) { + copiedState.Skip_TC_Rejection_Report(_tmp_1); + obsw_M001_1::_ProjectionWrite_Skip_TC_Rejection_Report writeState = copiedState._update_for_Skip_TC_Rejection_Report(); + std::unordered_map<obsw_M001_1::_ProjectionRead_Skip_TC_Rejection_Report, obsw_M001_1::_ProjectionWrite_Skip_TC_Rejection_Report, obsw_M001_1::_ProjectionRead_Skip_TC_Rejection_Report::Hash, obsw_M001_1::_ProjectionRead_Skip_TC_Rejection_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Rejection_Report; + _OpCache_with_parameter_Skip_TC_Rejection_Report.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_Skip_TC_Rejection_Report_lock(_ProjectionRead_Skip_TC_Rejection_Report_mutex); + _OpCache_Skip_TC_Rejection_Report.insert({param, _OpCache_with_parameter_Skip_TC_Rejection_Report}); } - copiedState.stateAccessedVia = "Skip_TC_Rejection_Report"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_8 = _trid_8_ptr->second; - for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_8) { - obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param; - - obsw_M001_1 copiedState = state._copy(); - obsw_M001_1::_ProjectionRead_Skip_TC_Rejection_Report readState = state._projected_state_for_Skip_TC_Rejection_Report(); - - auto _OpCache_with_parameter_Skip_TC_Rejection_Report_ptr = _OpCache_Skip_TC_Rejection_Report.find(param); - if(_OpCache_with_parameter_Skip_TC_Rejection_Report_ptr == _OpCache_Skip_TC_Rejection_Report.end()) { + } else { + std::unordered_map<obsw_M001_1::_ProjectionRead_Skip_TC_Rejection_Report, obsw_M001_1::_ProjectionWrite_Skip_TC_Rejection_Report, obsw_M001_1::_ProjectionRead_Skip_TC_Rejection_Report::Hash, obsw_M001_1::_ProjectionRead_Skip_TC_Rejection_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Rejection_Report = _OpCache_with_parameter_Skip_TC_Rejection_Report_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_Skip_TC_Rejection_Report.find(readState); + if(writeState_ptr != _OpCache_with_parameter_Skip_TC_Rejection_Report.end()) { + obsw_M001_1::_ProjectionWrite_Skip_TC_Rejection_Report writeState = writeState_ptr->second; + copiedState._apply_update_for_Skip_TC_Rejection_Report(writeState); + } else { copiedState.Skip_TC_Rejection_Report(_tmp_1); obsw_M001_1::_ProjectionWrite_Skip_TC_Rejection_Report writeState = copiedState._update_for_Skip_TC_Rejection_Report(); - std::unordered_map<obsw_M001_1::_ProjectionRead_Skip_TC_Rejection_Report, obsw_M001_1::_ProjectionWrite_Skip_TC_Rejection_Report, obsw_M001_1::_ProjectionRead_Skip_TC_Rejection_Report::Hash, obsw_M001_1::_ProjectionRead_Skip_TC_Rejection_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Rejection_Report; - _OpCache_with_parameter_Skip_TC_Rejection_Report.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_Skip_TC_Rejection_Report_lock(_ProjectionRead_Skip_TC_Rejection_Report_mutex); - _OpCache_Skip_TC_Rejection_Report.insert({param, _OpCache_with_parameter_Skip_TC_Rejection_Report}); - } - - } else { - std::unordered_map<obsw_M001_1::_ProjectionRead_Skip_TC_Rejection_Report, obsw_M001_1::_ProjectionWrite_Skip_TC_Rejection_Report, obsw_M001_1::_ProjectionRead_Skip_TC_Rejection_Report::Hash, obsw_M001_1::_ProjectionRead_Skip_TC_Rejection_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Rejection_Report = _OpCache_with_parameter_Skip_TC_Rejection_Report_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_Skip_TC_Rejection_Report.find(readState); - if(writeState_ptr != _OpCache_with_parameter_Skip_TC_Rejection_Report.end()) { - obsw_M001_1::_ProjectionWrite_Skip_TC_Rejection_Report writeState = writeState_ptr->second; - copiedState._apply_update_for_Skip_TC_Rejection_Report(writeState); - } else { - copiedState.Skip_TC_Rejection_Report(_tmp_1); - obsw_M001_1::_ProjectionWrite_Skip_TC_Rejection_Report writeState = copiedState._update_for_Skip_TC_Rejection_Report(); - { - std::unique_lock<std::mutex> _ProjectionRead_Skip_TC_Rejection_Report_lock(_ProjectionRead_Skip_TC_Rejection_Report_mutex); - _OpCache_with_parameter_Skip_TC_Rejection_Report.insert({readState, writeState}); - } + _OpCache_with_parameter_Skip_TC_Rejection_Report.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "Skip_TC_Rejection_Report"; - result.insert(copiedState); + copiedState.stateAccessedVia = "Skip_TC_Rejection_Report"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } obsw_M001_1::_ProjectionRead__tr_Execute_TC_Successfully read__tr_Execute_TC_Successfully_state = state._projected_state_for__tr_Execute_TC_Successfully(); + BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_9; auto _trid_9_ptr = _OpCache_tr_Execute_TC_Successfully.find(read__tr_Execute_TC_Successfully_state); if(_trid_9_ptr == _OpCache_tr_Execute_TC_Successfully.end()) { - BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_9 = state._tr_Execute_TC_Successfully(); + _trid_9 = state._tr_Execute_TC_Successfully(); { std::unique_lock<std::mutex> _ProjectionRead__tr_Execute_TC_Successfully_lock(_ProjectionRead__tr_Execute_TC_Successfully_mutex); _OpCache_tr_Execute_TC_Successfully.insert({read__tr_Execute_TC_Successfully_state, _trid_9}); } - for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_9) { - obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param; - - obsw_M001_1 copiedState = state._copy(); - obsw_M001_1::_ProjectionRead_Execute_TC_Successfully readState = state._projected_state_for_Execute_TC_Successfully(); + } else { + _trid_9 = _trid_9_ptr->second; + } - auto _OpCache_with_parameter_Execute_TC_Successfully_ptr = _OpCache_Execute_TC_Successfully.find(param); - if(_OpCache_with_parameter_Execute_TC_Successfully_ptr == _OpCache_Execute_TC_Successfully.end()) { - copiedState.Execute_TC_Successfully(_tmp_1); - obsw_M001_1::_ProjectionWrite_Execute_TC_Successfully writeState = copiedState._update_for_Execute_TC_Successfully(); - std::unordered_map<obsw_M001_1::_ProjectionRead_Execute_TC_Successfully, obsw_M001_1::_ProjectionWrite_Execute_TC_Successfully, obsw_M001_1::_ProjectionRead_Execute_TC_Successfully::Hash, obsw_M001_1::_ProjectionRead_Execute_TC_Successfully::HashEqual> _OpCache_with_parameter_Execute_TC_Successfully; - _OpCache_with_parameter_Execute_TC_Successfully.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_Execute_TC_Successfully_lock(_ProjectionRead_Execute_TC_Successfully_mutex); - _OpCache_Execute_TC_Successfully.insert({param, _OpCache_with_parameter_Execute_TC_Successfully}); - } + for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_9) { + obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param; - } else { - std::unordered_map<obsw_M001_1::_ProjectionRead_Execute_TC_Successfully, obsw_M001_1::_ProjectionWrite_Execute_TC_Successfully, obsw_M001_1::_ProjectionRead_Execute_TC_Successfully::Hash, obsw_M001_1::_ProjectionRead_Execute_TC_Successfully::HashEqual> _OpCache_with_parameter_Execute_TC_Successfully = _OpCache_with_parameter_Execute_TC_Successfully_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_Execute_TC_Successfully.find(readState); - if(writeState_ptr != _OpCache_with_parameter_Execute_TC_Successfully.end()) { - obsw_M001_1::_ProjectionWrite_Execute_TC_Successfully writeState = writeState_ptr->second; - copiedState._apply_update_for_Execute_TC_Successfully(writeState); - } else { - copiedState.Execute_TC_Successfully(_tmp_1); - obsw_M001_1::_ProjectionWrite_Execute_TC_Successfully writeState = copiedState._update_for_Execute_TC_Successfully(); - { - std::unique_lock<std::mutex> _ProjectionRead_Execute_TC_Successfully_lock(_ProjectionRead_Execute_TC_Successfully_mutex); - _OpCache_with_parameter_Execute_TC_Successfully.insert({readState, writeState}); - } - } + obsw_M001_1 copiedState = state._copy(); + obsw_M001_1::_ProjectionRead_Execute_TC_Successfully readState = state._projected_state_for_Execute_TC_Successfully(); + + auto _OpCache_with_parameter_Execute_TC_Successfully_ptr = _OpCache_Execute_TC_Successfully.find(param); + if(_OpCache_with_parameter_Execute_TC_Successfully_ptr == _OpCache_Execute_TC_Successfully.end()) { + copiedState.Execute_TC_Successfully(_tmp_1); + obsw_M001_1::_ProjectionWrite_Execute_TC_Successfully writeState = copiedState._update_for_Execute_TC_Successfully(); + std::unordered_map<obsw_M001_1::_ProjectionRead_Execute_TC_Successfully, obsw_M001_1::_ProjectionWrite_Execute_TC_Successfully, obsw_M001_1::_ProjectionRead_Execute_TC_Successfully::Hash, obsw_M001_1::_ProjectionRead_Execute_TC_Successfully::HashEqual> _OpCache_with_parameter_Execute_TC_Successfully; + _OpCache_with_parameter_Execute_TC_Successfully.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_Execute_TC_Successfully_lock(_ProjectionRead_Execute_TC_Successfully_mutex); + _OpCache_Execute_TC_Successfully.insert({param, _OpCache_with_parameter_Execute_TC_Successfully}); } - copiedState.stateAccessedVia = "Execute_TC_Successfully"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_9 = _trid_9_ptr->second; - for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_9) { - obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param; - - obsw_M001_1 copiedState = state._copy(); - obsw_M001_1::_ProjectionRead_Execute_TC_Successfully readState = state._projected_state_for_Execute_TC_Successfully(); - - auto _OpCache_with_parameter_Execute_TC_Successfully_ptr = _OpCache_Execute_TC_Successfully.find(param); - if(_OpCache_with_parameter_Execute_TC_Successfully_ptr == _OpCache_Execute_TC_Successfully.end()) { + } else { + std::unordered_map<obsw_M001_1::_ProjectionRead_Execute_TC_Successfully, obsw_M001_1::_ProjectionWrite_Execute_TC_Successfully, obsw_M001_1::_ProjectionRead_Execute_TC_Successfully::Hash, obsw_M001_1::_ProjectionRead_Execute_TC_Successfully::HashEqual> _OpCache_with_parameter_Execute_TC_Successfully = _OpCache_with_parameter_Execute_TC_Successfully_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_Execute_TC_Successfully.find(readState); + if(writeState_ptr != _OpCache_with_parameter_Execute_TC_Successfully.end()) { + obsw_M001_1::_ProjectionWrite_Execute_TC_Successfully writeState = writeState_ptr->second; + copiedState._apply_update_for_Execute_TC_Successfully(writeState); + } else { copiedState.Execute_TC_Successfully(_tmp_1); obsw_M001_1::_ProjectionWrite_Execute_TC_Successfully writeState = copiedState._update_for_Execute_TC_Successfully(); - std::unordered_map<obsw_M001_1::_ProjectionRead_Execute_TC_Successfully, obsw_M001_1::_ProjectionWrite_Execute_TC_Successfully, obsw_M001_1::_ProjectionRead_Execute_TC_Successfully::Hash, obsw_M001_1::_ProjectionRead_Execute_TC_Successfully::HashEqual> _OpCache_with_parameter_Execute_TC_Successfully; - _OpCache_with_parameter_Execute_TC_Successfully.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_Execute_TC_Successfully_lock(_ProjectionRead_Execute_TC_Successfully_mutex); - _OpCache_Execute_TC_Successfully.insert({param, _OpCache_with_parameter_Execute_TC_Successfully}); - } - - } else { - std::unordered_map<obsw_M001_1::_ProjectionRead_Execute_TC_Successfully, obsw_M001_1::_ProjectionWrite_Execute_TC_Successfully, obsw_M001_1::_ProjectionRead_Execute_TC_Successfully::Hash, obsw_M001_1::_ProjectionRead_Execute_TC_Successfully::HashEqual> _OpCache_with_parameter_Execute_TC_Successfully = _OpCache_with_parameter_Execute_TC_Successfully_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_Execute_TC_Successfully.find(readState); - if(writeState_ptr != _OpCache_with_parameter_Execute_TC_Successfully.end()) { - obsw_M001_1::_ProjectionWrite_Execute_TC_Successfully writeState = writeState_ptr->second; - copiedState._apply_update_for_Execute_TC_Successfully(writeState); - } else { - copiedState.Execute_TC_Successfully(_tmp_1); - obsw_M001_1::_ProjectionWrite_Execute_TC_Successfully writeState = copiedState._update_for_Execute_TC_Successfully(); - { - std::unique_lock<std::mutex> _ProjectionRead_Execute_TC_Successfully_lock(_ProjectionRead_Execute_TC_Successfully_mutex); - _OpCache_with_parameter_Execute_TC_Successfully.insert({readState, writeState}); - } + _OpCache_with_parameter_Execute_TC_Successfully.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "Execute_TC_Successfully"; - result.insert(copiedState); + copiedState.stateAccessedVia = "Execute_TC_Successfully"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } obsw_M001_1::_ProjectionRead__tr_Reset_TM_Buffer read__tr_Reset_TM_Buffer_state = state._projected_state_for__tr_Reset_TM_Buffer(); + BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_10; auto _trid_10_ptr = _OpCache_tr_Reset_TM_Buffer.find(read__tr_Reset_TM_Buffer_state); if(_trid_10_ptr == _OpCache_tr_Reset_TM_Buffer.end()) { - BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_10 = state._tr_Reset_TM_Buffer(); + _trid_10 = state._tr_Reset_TM_Buffer(); { std::unique_lock<std::mutex> _ProjectionRead__tr_Reset_TM_Buffer_lock(_ProjectionRead__tr_Reset_TM_Buffer_mutex); _OpCache_tr_Reset_TM_Buffer.insert({read__tr_Reset_TM_Buffer_state, _trid_10}); } - for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_10) { - obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param; - - obsw_M001_1 copiedState = state._copy(); - obsw_M001_1::_ProjectionRead_Reset_TM_Buffer readState = state._projected_state_for_Reset_TM_Buffer(); + } else { + _trid_10 = _trid_10_ptr->second; + } - auto _OpCache_with_parameter_Reset_TM_Buffer_ptr = _OpCache_Reset_TM_Buffer.find(param); - if(_OpCache_with_parameter_Reset_TM_Buffer_ptr == _OpCache_Reset_TM_Buffer.end()) { - copiedState.Reset_TM_Buffer(_tmp_1); - obsw_M001_1::_ProjectionWrite_Reset_TM_Buffer writeState = copiedState._update_for_Reset_TM_Buffer(); - std::unordered_map<obsw_M001_1::_ProjectionRead_Reset_TM_Buffer, obsw_M001_1::_ProjectionWrite_Reset_TM_Buffer, obsw_M001_1::_ProjectionRead_Reset_TM_Buffer::Hash, obsw_M001_1::_ProjectionRead_Reset_TM_Buffer::HashEqual> _OpCache_with_parameter_Reset_TM_Buffer; - _OpCache_with_parameter_Reset_TM_Buffer.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_Reset_TM_Buffer_lock(_ProjectionRead_Reset_TM_Buffer_mutex); - _OpCache_Reset_TM_Buffer.insert({param, _OpCache_with_parameter_Reset_TM_Buffer}); - } + for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_10) { + obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param; - } else { - std::unordered_map<obsw_M001_1::_ProjectionRead_Reset_TM_Buffer, obsw_M001_1::_ProjectionWrite_Reset_TM_Buffer, obsw_M001_1::_ProjectionRead_Reset_TM_Buffer::Hash, obsw_M001_1::_ProjectionRead_Reset_TM_Buffer::HashEqual> _OpCache_with_parameter_Reset_TM_Buffer = _OpCache_with_parameter_Reset_TM_Buffer_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_Reset_TM_Buffer.find(readState); - if(writeState_ptr != _OpCache_with_parameter_Reset_TM_Buffer.end()) { - obsw_M001_1::_ProjectionWrite_Reset_TM_Buffer writeState = writeState_ptr->second; - copiedState._apply_update_for_Reset_TM_Buffer(writeState); - } else { - copiedState.Reset_TM_Buffer(_tmp_1); - obsw_M001_1::_ProjectionWrite_Reset_TM_Buffer writeState = copiedState._update_for_Reset_TM_Buffer(); - { - std::unique_lock<std::mutex> _ProjectionRead_Reset_TM_Buffer_lock(_ProjectionRead_Reset_TM_Buffer_mutex); - _OpCache_with_parameter_Reset_TM_Buffer.insert({readState, writeState}); - } - } + obsw_M001_1 copiedState = state._copy(); + obsw_M001_1::_ProjectionRead_Reset_TM_Buffer readState = state._projected_state_for_Reset_TM_Buffer(); + + auto _OpCache_with_parameter_Reset_TM_Buffer_ptr = _OpCache_Reset_TM_Buffer.find(param); + if(_OpCache_with_parameter_Reset_TM_Buffer_ptr == _OpCache_Reset_TM_Buffer.end()) { + copiedState.Reset_TM_Buffer(_tmp_1); + obsw_M001_1::_ProjectionWrite_Reset_TM_Buffer writeState = copiedState._update_for_Reset_TM_Buffer(); + std::unordered_map<obsw_M001_1::_ProjectionRead_Reset_TM_Buffer, obsw_M001_1::_ProjectionWrite_Reset_TM_Buffer, obsw_M001_1::_ProjectionRead_Reset_TM_Buffer::Hash, obsw_M001_1::_ProjectionRead_Reset_TM_Buffer::HashEqual> _OpCache_with_parameter_Reset_TM_Buffer; + _OpCache_with_parameter_Reset_TM_Buffer.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_Reset_TM_Buffer_lock(_ProjectionRead_Reset_TM_Buffer_mutex); + _OpCache_Reset_TM_Buffer.insert({param, _OpCache_with_parameter_Reset_TM_Buffer}); } - copiedState.stateAccessedVia = "Reset_TM_Buffer"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_10 = _trid_10_ptr->second; - for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_10) { - obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param; - - obsw_M001_1 copiedState = state._copy(); - obsw_M001_1::_ProjectionRead_Reset_TM_Buffer readState = state._projected_state_for_Reset_TM_Buffer(); - - auto _OpCache_with_parameter_Reset_TM_Buffer_ptr = _OpCache_Reset_TM_Buffer.find(param); - if(_OpCache_with_parameter_Reset_TM_Buffer_ptr == _OpCache_Reset_TM_Buffer.end()) { + } else { + std::unordered_map<obsw_M001_1::_ProjectionRead_Reset_TM_Buffer, obsw_M001_1::_ProjectionWrite_Reset_TM_Buffer, obsw_M001_1::_ProjectionRead_Reset_TM_Buffer::Hash, obsw_M001_1::_ProjectionRead_Reset_TM_Buffer::HashEqual> _OpCache_with_parameter_Reset_TM_Buffer = _OpCache_with_parameter_Reset_TM_Buffer_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_Reset_TM_Buffer.find(readState); + if(writeState_ptr != _OpCache_with_parameter_Reset_TM_Buffer.end()) { + obsw_M001_1::_ProjectionWrite_Reset_TM_Buffer writeState = writeState_ptr->second; + copiedState._apply_update_for_Reset_TM_Buffer(writeState); + } else { copiedState.Reset_TM_Buffer(_tmp_1); obsw_M001_1::_ProjectionWrite_Reset_TM_Buffer writeState = copiedState._update_for_Reset_TM_Buffer(); - std::unordered_map<obsw_M001_1::_ProjectionRead_Reset_TM_Buffer, obsw_M001_1::_ProjectionWrite_Reset_TM_Buffer, obsw_M001_1::_ProjectionRead_Reset_TM_Buffer::Hash, obsw_M001_1::_ProjectionRead_Reset_TM_Buffer::HashEqual> _OpCache_with_parameter_Reset_TM_Buffer; - _OpCache_with_parameter_Reset_TM_Buffer.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_Reset_TM_Buffer_lock(_ProjectionRead_Reset_TM_Buffer_mutex); - _OpCache_Reset_TM_Buffer.insert({param, _OpCache_with_parameter_Reset_TM_Buffer}); - } - - } else { - std::unordered_map<obsw_M001_1::_ProjectionRead_Reset_TM_Buffer, obsw_M001_1::_ProjectionWrite_Reset_TM_Buffer, obsw_M001_1::_ProjectionRead_Reset_TM_Buffer::Hash, obsw_M001_1::_ProjectionRead_Reset_TM_Buffer::HashEqual> _OpCache_with_parameter_Reset_TM_Buffer = _OpCache_with_parameter_Reset_TM_Buffer_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_Reset_TM_Buffer.find(readState); - if(writeState_ptr != _OpCache_with_parameter_Reset_TM_Buffer.end()) { - obsw_M001_1::_ProjectionWrite_Reset_TM_Buffer writeState = writeState_ptr->second; - copiedState._apply_update_for_Reset_TM_Buffer(writeState); - } else { - copiedState.Reset_TM_Buffer(_tmp_1); - obsw_M001_1::_ProjectionWrite_Reset_TM_Buffer writeState = copiedState._update_for_Reset_TM_Buffer(); - { - std::unique_lock<std::mutex> _ProjectionRead_Reset_TM_Buffer_lock(_ProjectionRead_Reset_TM_Buffer_mutex); - _OpCache_with_parameter_Reset_TM_Buffer.insert({readState, writeState}); - } + _OpCache_with_parameter_Reset_TM_Buffer.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "Reset_TM_Buffer"; - result.insert(copiedState); + copiedState.stateAccessedVia = "Reset_TM_Buffer"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } obsw_M001_1::_ProjectionRead__tr_Fail_TC_Execution read__tr_Fail_TC_Execution_state = state._projected_state_for__tr_Fail_TC_Execution(); + BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_11; auto _trid_11_ptr = _OpCache_tr_Fail_TC_Execution.find(read__tr_Fail_TC_Execution_state); if(_trid_11_ptr == _OpCache_tr_Fail_TC_Execution.end()) { - BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_11 = state._tr_Fail_TC_Execution(); + _trid_11 = state._tr_Fail_TC_Execution(); { std::unique_lock<std::mutex> _ProjectionRead__tr_Fail_TC_Execution_lock(_ProjectionRead__tr_Fail_TC_Execution_mutex); _OpCache_tr_Fail_TC_Execution.insert({read__tr_Fail_TC_Execution_state, _trid_11}); } - for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_11) { - obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param; - - obsw_M001_1 copiedState = state._copy(); - obsw_M001_1::_ProjectionRead_Fail_TC_Execution readState = state._projected_state_for_Fail_TC_Execution(); + } else { + _trid_11 = _trid_11_ptr->second; + } - auto _OpCache_with_parameter_Fail_TC_Execution_ptr = _OpCache_Fail_TC_Execution.find(param); - if(_OpCache_with_parameter_Fail_TC_Execution_ptr == _OpCache_Fail_TC_Execution.end()) { - copiedState.Fail_TC_Execution(_tmp_1); - obsw_M001_1::_ProjectionWrite_Fail_TC_Execution writeState = copiedState._update_for_Fail_TC_Execution(); - std::unordered_map<obsw_M001_1::_ProjectionRead_Fail_TC_Execution, obsw_M001_1::_ProjectionWrite_Fail_TC_Execution, obsw_M001_1::_ProjectionRead_Fail_TC_Execution::Hash, obsw_M001_1::_ProjectionRead_Fail_TC_Execution::HashEqual> _OpCache_with_parameter_Fail_TC_Execution; - _OpCache_with_parameter_Fail_TC_Execution.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_Fail_TC_Execution_lock(_ProjectionRead_Fail_TC_Execution_mutex); - _OpCache_Fail_TC_Execution.insert({param, _OpCache_with_parameter_Fail_TC_Execution}); - } + for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_11) { + obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param; - } else { - std::unordered_map<obsw_M001_1::_ProjectionRead_Fail_TC_Execution, obsw_M001_1::_ProjectionWrite_Fail_TC_Execution, obsw_M001_1::_ProjectionRead_Fail_TC_Execution::Hash, obsw_M001_1::_ProjectionRead_Fail_TC_Execution::HashEqual> _OpCache_with_parameter_Fail_TC_Execution = _OpCache_with_parameter_Fail_TC_Execution_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_Fail_TC_Execution.find(readState); - if(writeState_ptr != _OpCache_with_parameter_Fail_TC_Execution.end()) { - obsw_M001_1::_ProjectionWrite_Fail_TC_Execution writeState = writeState_ptr->second; - copiedState._apply_update_for_Fail_TC_Execution(writeState); - } else { - copiedState.Fail_TC_Execution(_tmp_1); - obsw_M001_1::_ProjectionWrite_Fail_TC_Execution writeState = copiedState._update_for_Fail_TC_Execution(); - { - std::unique_lock<std::mutex> _ProjectionRead_Fail_TC_Execution_lock(_ProjectionRead_Fail_TC_Execution_mutex); - _OpCache_with_parameter_Fail_TC_Execution.insert({readState, writeState}); - } - } + obsw_M001_1 copiedState = state._copy(); + obsw_M001_1::_ProjectionRead_Fail_TC_Execution readState = state._projected_state_for_Fail_TC_Execution(); + + auto _OpCache_with_parameter_Fail_TC_Execution_ptr = _OpCache_Fail_TC_Execution.find(param); + if(_OpCache_with_parameter_Fail_TC_Execution_ptr == _OpCache_Fail_TC_Execution.end()) { + copiedState.Fail_TC_Execution(_tmp_1); + obsw_M001_1::_ProjectionWrite_Fail_TC_Execution writeState = copiedState._update_for_Fail_TC_Execution(); + std::unordered_map<obsw_M001_1::_ProjectionRead_Fail_TC_Execution, obsw_M001_1::_ProjectionWrite_Fail_TC_Execution, obsw_M001_1::_ProjectionRead_Fail_TC_Execution::Hash, obsw_M001_1::_ProjectionRead_Fail_TC_Execution::HashEqual> _OpCache_with_parameter_Fail_TC_Execution; + _OpCache_with_parameter_Fail_TC_Execution.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_Fail_TC_Execution_lock(_ProjectionRead_Fail_TC_Execution_mutex); + _OpCache_Fail_TC_Execution.insert({param, _OpCache_with_parameter_Fail_TC_Execution}); } - copiedState.stateAccessedVia = "Fail_TC_Execution"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_11 = _trid_11_ptr->second; - for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_11) { - obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param; - - obsw_M001_1 copiedState = state._copy(); - obsw_M001_1::_ProjectionRead_Fail_TC_Execution readState = state._projected_state_for_Fail_TC_Execution(); - - auto _OpCache_with_parameter_Fail_TC_Execution_ptr = _OpCache_Fail_TC_Execution.find(param); - if(_OpCache_with_parameter_Fail_TC_Execution_ptr == _OpCache_Fail_TC_Execution.end()) { + } else { + std::unordered_map<obsw_M001_1::_ProjectionRead_Fail_TC_Execution, obsw_M001_1::_ProjectionWrite_Fail_TC_Execution, obsw_M001_1::_ProjectionRead_Fail_TC_Execution::Hash, obsw_M001_1::_ProjectionRead_Fail_TC_Execution::HashEqual> _OpCache_with_parameter_Fail_TC_Execution = _OpCache_with_parameter_Fail_TC_Execution_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_Fail_TC_Execution.find(readState); + if(writeState_ptr != _OpCache_with_parameter_Fail_TC_Execution.end()) { + obsw_M001_1::_ProjectionWrite_Fail_TC_Execution writeState = writeState_ptr->second; + copiedState._apply_update_for_Fail_TC_Execution(writeState); + } else { copiedState.Fail_TC_Execution(_tmp_1); obsw_M001_1::_ProjectionWrite_Fail_TC_Execution writeState = copiedState._update_for_Fail_TC_Execution(); - std::unordered_map<obsw_M001_1::_ProjectionRead_Fail_TC_Execution, obsw_M001_1::_ProjectionWrite_Fail_TC_Execution, obsw_M001_1::_ProjectionRead_Fail_TC_Execution::Hash, obsw_M001_1::_ProjectionRead_Fail_TC_Execution::HashEqual> _OpCache_with_parameter_Fail_TC_Execution; - _OpCache_with_parameter_Fail_TC_Execution.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_Fail_TC_Execution_lock(_ProjectionRead_Fail_TC_Execution_mutex); - _OpCache_Fail_TC_Execution.insert({param, _OpCache_with_parameter_Fail_TC_Execution}); - } - - } else { - std::unordered_map<obsw_M001_1::_ProjectionRead_Fail_TC_Execution, obsw_M001_1::_ProjectionWrite_Fail_TC_Execution, obsw_M001_1::_ProjectionRead_Fail_TC_Execution::Hash, obsw_M001_1::_ProjectionRead_Fail_TC_Execution::HashEqual> _OpCache_with_parameter_Fail_TC_Execution = _OpCache_with_parameter_Fail_TC_Execution_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_Fail_TC_Execution.find(readState); - if(writeState_ptr != _OpCache_with_parameter_Fail_TC_Execution.end()) { - obsw_M001_1::_ProjectionWrite_Fail_TC_Execution writeState = writeState_ptr->second; - copiedState._apply_update_for_Fail_TC_Execution(writeState); - } else { - copiedState.Fail_TC_Execution(_tmp_1); - obsw_M001_1::_ProjectionWrite_Fail_TC_Execution writeState = copiedState._update_for_Fail_TC_Execution(); - { - std::unique_lock<std::mutex> _ProjectionRead_Fail_TC_Execution_lock(_ProjectionRead_Fail_TC_Execution_mutex); - _OpCache_with_parameter_Fail_TC_Execution.insert({readState, writeState}); - } + _OpCache_with_parameter_Fail_TC_Execution.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "Fail_TC_Execution"; - result.insert(copiedState); + copiedState.stateAccessedVia = "Fail_TC_Execution"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } obsw_M001_1::_ProjectionRead__tr_Report_TC_Execution_Success read__tr_Report_TC_Execution_Success_state = state._projected_state_for__tr_Report_TC_Execution_Success(); + BSet<BTuple<BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::TM_SET >, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL >> _trid_12; auto _trid_12_ptr = _OpCache_tr_Report_TC_Execution_Success.find(read__tr_Report_TC_Execution_Success_state); if(_trid_12_ptr == _OpCache_tr_Report_TC_Execution_Success.end()) { - BSet<BTuple<BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::TM_SET >, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL >> _trid_12 = state._tr_Report_TC_Execution_Success(); + _trid_12 = state._tr_Report_TC_Execution_Success(); { std::unique_lock<std::mutex> _ProjectionRead__tr_Report_TC_Execution_Success_lock(_ProjectionRead__tr_Report_TC_Execution_Success_mutex); _OpCache_tr_Report_TC_Execution_Success.insert({read__tr_Report_TC_Execution_Success_state, _trid_12}); } - for(const BTuple<BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::TM_SET >, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL >& param : _trid_12) { - obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_1 = param.projection2(); - BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::TM_SET > _tmp_2 = param.projection1(); - obsw_M001_1::TM_SET _tmp_3 = _tmp_2.projection2(); - obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_4 = _tmp_2.projection1(); - - obsw_M001_1 copiedState = state._copy(); - obsw_M001_1::_ProjectionRead_Report_TC_Execution_Success readState = state._projected_state_for_Report_TC_Execution_Success(); + } else { + _trid_12 = _trid_12_ptr->second; + } - auto _OpCache_with_parameter_Report_TC_Execution_Success_ptr = _OpCache_Report_TC_Execution_Success.find(param); - if(_OpCache_with_parameter_Report_TC_Execution_Success_ptr == _OpCache_Report_TC_Execution_Success.end()) { - copiedState.Report_TC_Execution_Success(_tmp_4, _tmp_3, _tmp_1); - obsw_M001_1::_ProjectionWrite_Report_TC_Execution_Success writeState = copiedState._update_for_Report_TC_Execution_Success(); - std::unordered_map<obsw_M001_1::_ProjectionRead_Report_TC_Execution_Success, obsw_M001_1::_ProjectionWrite_Report_TC_Execution_Success, obsw_M001_1::_ProjectionRead_Report_TC_Execution_Success::Hash, obsw_M001_1::_ProjectionRead_Report_TC_Execution_Success::HashEqual> _OpCache_with_parameter_Report_TC_Execution_Success; - _OpCache_with_parameter_Report_TC_Execution_Success.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_Report_TC_Execution_Success_lock(_ProjectionRead_Report_TC_Execution_Success_mutex); - _OpCache_Report_TC_Execution_Success.insert({param, _OpCache_with_parameter_Report_TC_Execution_Success}); - } + for(const BTuple<BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::TM_SET >, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL >& param : _trid_12) { + obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_1 = param.projection2(); + BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::TM_SET > _tmp_2 = param.projection1(); + obsw_M001_1::TM_SET _tmp_3 = _tmp_2.projection2(); + obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_4 = _tmp_2.projection1(); - } else { - std::unordered_map<obsw_M001_1::_ProjectionRead_Report_TC_Execution_Success, obsw_M001_1::_ProjectionWrite_Report_TC_Execution_Success, obsw_M001_1::_ProjectionRead_Report_TC_Execution_Success::Hash, obsw_M001_1::_ProjectionRead_Report_TC_Execution_Success::HashEqual> _OpCache_with_parameter_Report_TC_Execution_Success = _OpCache_with_parameter_Report_TC_Execution_Success_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_Report_TC_Execution_Success.find(readState); - if(writeState_ptr != _OpCache_with_parameter_Report_TC_Execution_Success.end()) { - obsw_M001_1::_ProjectionWrite_Report_TC_Execution_Success writeState = writeState_ptr->second; - copiedState._apply_update_for_Report_TC_Execution_Success(writeState); - } else { - copiedState.Report_TC_Execution_Success(_tmp_4, _tmp_3, _tmp_1); - obsw_M001_1::_ProjectionWrite_Report_TC_Execution_Success writeState = copiedState._update_for_Report_TC_Execution_Success(); - { - std::unique_lock<std::mutex> _ProjectionRead_Report_TC_Execution_Success_lock(_ProjectionRead_Report_TC_Execution_Success_mutex); - _OpCache_with_parameter_Report_TC_Execution_Success.insert({readState, writeState}); - } - } + obsw_M001_1 copiedState = state._copy(); + obsw_M001_1::_ProjectionRead_Report_TC_Execution_Success readState = state._projected_state_for_Report_TC_Execution_Success(); + + auto _OpCache_with_parameter_Report_TC_Execution_Success_ptr = _OpCache_Report_TC_Execution_Success.find(param); + if(_OpCache_with_parameter_Report_TC_Execution_Success_ptr == _OpCache_Report_TC_Execution_Success.end()) { + copiedState.Report_TC_Execution_Success(_tmp_4, _tmp_3, _tmp_1); + obsw_M001_1::_ProjectionWrite_Report_TC_Execution_Success writeState = copiedState._update_for_Report_TC_Execution_Success(); + std::unordered_map<obsw_M001_1::_ProjectionRead_Report_TC_Execution_Success, obsw_M001_1::_ProjectionWrite_Report_TC_Execution_Success, obsw_M001_1::_ProjectionRead_Report_TC_Execution_Success::Hash, obsw_M001_1::_ProjectionRead_Report_TC_Execution_Success::HashEqual> _OpCache_with_parameter_Report_TC_Execution_Success; + _OpCache_with_parameter_Report_TC_Execution_Success.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_Report_TC_Execution_Success_lock(_ProjectionRead_Report_TC_Execution_Success_mutex); + _OpCache_Report_TC_Execution_Success.insert({param, _OpCache_with_parameter_Report_TC_Execution_Success}); } - copiedState.stateAccessedVia = "Report_TC_Execution_Success"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<BTuple<BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::TM_SET >, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL >> _trid_12 = _trid_12_ptr->second; - for(const BTuple<BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::TM_SET >, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL >& param : _trid_12) { - obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_1 = param.projection2(); - BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::TM_SET > _tmp_2 = param.projection1(); - obsw_M001_1::TM_SET _tmp_3 = _tmp_2.projection2(); - obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_4 = _tmp_2.projection1(); - - obsw_M001_1 copiedState = state._copy(); - obsw_M001_1::_ProjectionRead_Report_TC_Execution_Success readState = state._projected_state_for_Report_TC_Execution_Success(); - - auto _OpCache_with_parameter_Report_TC_Execution_Success_ptr = _OpCache_Report_TC_Execution_Success.find(param); - if(_OpCache_with_parameter_Report_TC_Execution_Success_ptr == _OpCache_Report_TC_Execution_Success.end()) { + } else { + std::unordered_map<obsw_M001_1::_ProjectionRead_Report_TC_Execution_Success, obsw_M001_1::_ProjectionWrite_Report_TC_Execution_Success, obsw_M001_1::_ProjectionRead_Report_TC_Execution_Success::Hash, obsw_M001_1::_ProjectionRead_Report_TC_Execution_Success::HashEqual> _OpCache_with_parameter_Report_TC_Execution_Success = _OpCache_with_parameter_Report_TC_Execution_Success_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_Report_TC_Execution_Success.find(readState); + if(writeState_ptr != _OpCache_with_parameter_Report_TC_Execution_Success.end()) { + obsw_M001_1::_ProjectionWrite_Report_TC_Execution_Success writeState = writeState_ptr->second; + copiedState._apply_update_for_Report_TC_Execution_Success(writeState); + } else { copiedState.Report_TC_Execution_Success(_tmp_4, _tmp_3, _tmp_1); obsw_M001_1::_ProjectionWrite_Report_TC_Execution_Success writeState = copiedState._update_for_Report_TC_Execution_Success(); - std::unordered_map<obsw_M001_1::_ProjectionRead_Report_TC_Execution_Success, obsw_M001_1::_ProjectionWrite_Report_TC_Execution_Success, obsw_M001_1::_ProjectionRead_Report_TC_Execution_Success::Hash, obsw_M001_1::_ProjectionRead_Report_TC_Execution_Success::HashEqual> _OpCache_with_parameter_Report_TC_Execution_Success; - _OpCache_with_parameter_Report_TC_Execution_Success.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_Report_TC_Execution_Success_lock(_ProjectionRead_Report_TC_Execution_Success_mutex); - _OpCache_Report_TC_Execution_Success.insert({param, _OpCache_with_parameter_Report_TC_Execution_Success}); - } - - } else { - std::unordered_map<obsw_M001_1::_ProjectionRead_Report_TC_Execution_Success, obsw_M001_1::_ProjectionWrite_Report_TC_Execution_Success, obsw_M001_1::_ProjectionRead_Report_TC_Execution_Success::Hash, obsw_M001_1::_ProjectionRead_Report_TC_Execution_Success::HashEqual> _OpCache_with_parameter_Report_TC_Execution_Success = _OpCache_with_parameter_Report_TC_Execution_Success_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_Report_TC_Execution_Success.find(readState); - if(writeState_ptr != _OpCache_with_parameter_Report_TC_Execution_Success.end()) { - obsw_M001_1::_ProjectionWrite_Report_TC_Execution_Success writeState = writeState_ptr->second; - copiedState._apply_update_for_Report_TC_Execution_Success(writeState); - } else { - copiedState.Report_TC_Execution_Success(_tmp_4, _tmp_3, _tmp_1); - obsw_M001_1::_ProjectionWrite_Report_TC_Execution_Success writeState = copiedState._update_for_Report_TC_Execution_Success(); - { - std::unique_lock<std::mutex> _ProjectionRead_Report_TC_Execution_Success_lock(_ProjectionRead_Report_TC_Execution_Success_mutex); - _OpCache_with_parameter_Report_TC_Execution_Success.insert({readState, writeState}); - } + _OpCache_with_parameter_Report_TC_Execution_Success.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "Report_TC_Execution_Success"; - result.insert(copiedState); + copiedState.stateAccessedVia = "Report_TC_Execution_Success"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } obsw_M001_1::_ProjectionRead__tr_Skip_TC_Success_Report read__tr_Skip_TC_Success_Report_state = state._projected_state_for__tr_Skip_TC_Success_Report(); + BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_13; auto _trid_13_ptr = _OpCache_tr_Skip_TC_Success_Report.find(read__tr_Skip_TC_Success_Report_state); if(_trid_13_ptr == _OpCache_tr_Skip_TC_Success_Report.end()) { - BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_13 = state._tr_Skip_TC_Success_Report(); + _trid_13 = state._tr_Skip_TC_Success_Report(); { std::unique_lock<std::mutex> _ProjectionRead__tr_Skip_TC_Success_Report_lock(_ProjectionRead__tr_Skip_TC_Success_Report_mutex); _OpCache_tr_Skip_TC_Success_Report.insert({read__tr_Skip_TC_Success_Report_state, _trid_13}); } - for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_13) { - obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param; - - obsw_M001_1 copiedState = state._copy(); - obsw_M001_1::_ProjectionRead_Skip_TC_Success_Report readState = state._projected_state_for_Skip_TC_Success_Report(); + } else { + _trid_13 = _trid_13_ptr->second; + } - auto _OpCache_with_parameter_Skip_TC_Success_Report_ptr = _OpCache_Skip_TC_Success_Report.find(param); - if(_OpCache_with_parameter_Skip_TC_Success_Report_ptr == _OpCache_Skip_TC_Success_Report.end()) { - copiedState.Skip_TC_Success_Report(_tmp_1); - obsw_M001_1::_ProjectionWrite_Skip_TC_Success_Report writeState = copiedState._update_for_Skip_TC_Success_Report(); - std::unordered_map<obsw_M001_1::_ProjectionRead_Skip_TC_Success_Report, obsw_M001_1::_ProjectionWrite_Skip_TC_Success_Report, obsw_M001_1::_ProjectionRead_Skip_TC_Success_Report::Hash, obsw_M001_1::_ProjectionRead_Skip_TC_Success_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Success_Report; - _OpCache_with_parameter_Skip_TC_Success_Report.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_Skip_TC_Success_Report_lock(_ProjectionRead_Skip_TC_Success_Report_mutex); - _OpCache_Skip_TC_Success_Report.insert({param, _OpCache_with_parameter_Skip_TC_Success_Report}); - } + for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_13) { + obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param; - } else { - std::unordered_map<obsw_M001_1::_ProjectionRead_Skip_TC_Success_Report, obsw_M001_1::_ProjectionWrite_Skip_TC_Success_Report, obsw_M001_1::_ProjectionRead_Skip_TC_Success_Report::Hash, obsw_M001_1::_ProjectionRead_Skip_TC_Success_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Success_Report = _OpCache_with_parameter_Skip_TC_Success_Report_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_Skip_TC_Success_Report.find(readState); - if(writeState_ptr != _OpCache_with_parameter_Skip_TC_Success_Report.end()) { - obsw_M001_1::_ProjectionWrite_Skip_TC_Success_Report writeState = writeState_ptr->second; - copiedState._apply_update_for_Skip_TC_Success_Report(writeState); - } else { - copiedState.Skip_TC_Success_Report(_tmp_1); - obsw_M001_1::_ProjectionWrite_Skip_TC_Success_Report writeState = copiedState._update_for_Skip_TC_Success_Report(); - { - std::unique_lock<std::mutex> _ProjectionRead_Skip_TC_Success_Report_lock(_ProjectionRead_Skip_TC_Success_Report_mutex); - _OpCache_with_parameter_Skip_TC_Success_Report.insert({readState, writeState}); - } - } + obsw_M001_1 copiedState = state._copy(); + obsw_M001_1::_ProjectionRead_Skip_TC_Success_Report readState = state._projected_state_for_Skip_TC_Success_Report(); + + auto _OpCache_with_parameter_Skip_TC_Success_Report_ptr = _OpCache_Skip_TC_Success_Report.find(param); + if(_OpCache_with_parameter_Skip_TC_Success_Report_ptr == _OpCache_Skip_TC_Success_Report.end()) { + copiedState.Skip_TC_Success_Report(_tmp_1); + obsw_M001_1::_ProjectionWrite_Skip_TC_Success_Report writeState = copiedState._update_for_Skip_TC_Success_Report(); + std::unordered_map<obsw_M001_1::_ProjectionRead_Skip_TC_Success_Report, obsw_M001_1::_ProjectionWrite_Skip_TC_Success_Report, obsw_M001_1::_ProjectionRead_Skip_TC_Success_Report::Hash, obsw_M001_1::_ProjectionRead_Skip_TC_Success_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Success_Report; + _OpCache_with_parameter_Skip_TC_Success_Report.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_Skip_TC_Success_Report_lock(_ProjectionRead_Skip_TC_Success_Report_mutex); + _OpCache_Skip_TC_Success_Report.insert({param, _OpCache_with_parameter_Skip_TC_Success_Report}); } - copiedState.stateAccessedVia = "Skip_TC_Success_Report"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_13 = _trid_13_ptr->second; - for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_13) { - obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param; - - obsw_M001_1 copiedState = state._copy(); - obsw_M001_1::_ProjectionRead_Skip_TC_Success_Report readState = state._projected_state_for_Skip_TC_Success_Report(); - - auto _OpCache_with_parameter_Skip_TC_Success_Report_ptr = _OpCache_Skip_TC_Success_Report.find(param); - if(_OpCache_with_parameter_Skip_TC_Success_Report_ptr == _OpCache_Skip_TC_Success_Report.end()) { + } else { + std::unordered_map<obsw_M001_1::_ProjectionRead_Skip_TC_Success_Report, obsw_M001_1::_ProjectionWrite_Skip_TC_Success_Report, obsw_M001_1::_ProjectionRead_Skip_TC_Success_Report::Hash, obsw_M001_1::_ProjectionRead_Skip_TC_Success_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Success_Report = _OpCache_with_parameter_Skip_TC_Success_Report_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_Skip_TC_Success_Report.find(readState); + if(writeState_ptr != _OpCache_with_parameter_Skip_TC_Success_Report.end()) { + obsw_M001_1::_ProjectionWrite_Skip_TC_Success_Report writeState = writeState_ptr->second; + copiedState._apply_update_for_Skip_TC_Success_Report(writeState); + } else { copiedState.Skip_TC_Success_Report(_tmp_1); obsw_M001_1::_ProjectionWrite_Skip_TC_Success_Report writeState = copiedState._update_for_Skip_TC_Success_Report(); - std::unordered_map<obsw_M001_1::_ProjectionRead_Skip_TC_Success_Report, obsw_M001_1::_ProjectionWrite_Skip_TC_Success_Report, obsw_M001_1::_ProjectionRead_Skip_TC_Success_Report::Hash, obsw_M001_1::_ProjectionRead_Skip_TC_Success_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Success_Report; - _OpCache_with_parameter_Skip_TC_Success_Report.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_Skip_TC_Success_Report_lock(_ProjectionRead_Skip_TC_Success_Report_mutex); - _OpCache_Skip_TC_Success_Report.insert({param, _OpCache_with_parameter_Skip_TC_Success_Report}); - } - - } else { - std::unordered_map<obsw_M001_1::_ProjectionRead_Skip_TC_Success_Report, obsw_M001_1::_ProjectionWrite_Skip_TC_Success_Report, obsw_M001_1::_ProjectionRead_Skip_TC_Success_Report::Hash, obsw_M001_1::_ProjectionRead_Skip_TC_Success_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Success_Report = _OpCache_with_parameter_Skip_TC_Success_Report_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_Skip_TC_Success_Report.find(readState); - if(writeState_ptr != _OpCache_with_parameter_Skip_TC_Success_Report.end()) { - obsw_M001_1::_ProjectionWrite_Skip_TC_Success_Report writeState = writeState_ptr->second; - copiedState._apply_update_for_Skip_TC_Success_Report(writeState); - } else { - copiedState.Skip_TC_Success_Report(_tmp_1); - obsw_M001_1::_ProjectionWrite_Skip_TC_Success_Report writeState = copiedState._update_for_Skip_TC_Success_Report(); - { - std::unique_lock<std::mutex> _ProjectionRead_Skip_TC_Success_Report_lock(_ProjectionRead_Skip_TC_Success_Report_mutex); - _OpCache_with_parameter_Skip_TC_Success_Report.insert({readState, writeState}); - } + _OpCache_with_parameter_Skip_TC_Success_Report.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "Skip_TC_Success_Report"; - result.insert(copiedState); + copiedState.stateAccessedVia = "Skip_TC_Success_Report"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } obsw_M001_1::_ProjectionRead__tr_Report_TC_Execution_Failure read__tr_Report_TC_Execution_Failure_state = state._projected_state_for__tr_Report_TC_Execution_Failure(); + BSet<BTuple<BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::TM_SET >, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL >> _trid_14; auto _trid_14_ptr = _OpCache_tr_Report_TC_Execution_Failure.find(read__tr_Report_TC_Execution_Failure_state); if(_trid_14_ptr == _OpCache_tr_Report_TC_Execution_Failure.end()) { - BSet<BTuple<BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::TM_SET >, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL >> _trid_14 = state._tr_Report_TC_Execution_Failure(); + _trid_14 = state._tr_Report_TC_Execution_Failure(); { std::unique_lock<std::mutex> _ProjectionRead__tr_Report_TC_Execution_Failure_lock(_ProjectionRead__tr_Report_TC_Execution_Failure_mutex); _OpCache_tr_Report_TC_Execution_Failure.insert({read__tr_Report_TC_Execution_Failure_state, _trid_14}); } - for(const BTuple<BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::TM_SET >, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL >& param : _trid_14) { - obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_1 = param.projection2(); - BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::TM_SET > _tmp_2 = param.projection1(); - obsw_M001_1::TM_SET _tmp_3 = _tmp_2.projection2(); - obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_4 = _tmp_2.projection1(); - - obsw_M001_1 copiedState = state._copy(); - obsw_M001_1::_ProjectionRead_Report_TC_Execution_Failure readState = state._projected_state_for_Report_TC_Execution_Failure(); + } else { + _trid_14 = _trid_14_ptr->second; + } - auto _OpCache_with_parameter_Report_TC_Execution_Failure_ptr = _OpCache_Report_TC_Execution_Failure.find(param); - if(_OpCache_with_parameter_Report_TC_Execution_Failure_ptr == _OpCache_Report_TC_Execution_Failure.end()) { - copiedState.Report_TC_Execution_Failure(_tmp_4, _tmp_3, _tmp_1); - obsw_M001_1::_ProjectionWrite_Report_TC_Execution_Failure writeState = copiedState._update_for_Report_TC_Execution_Failure(); - std::unordered_map<obsw_M001_1::_ProjectionRead_Report_TC_Execution_Failure, obsw_M001_1::_ProjectionWrite_Report_TC_Execution_Failure, obsw_M001_1::_ProjectionRead_Report_TC_Execution_Failure::Hash, obsw_M001_1::_ProjectionRead_Report_TC_Execution_Failure::HashEqual> _OpCache_with_parameter_Report_TC_Execution_Failure; - _OpCache_with_parameter_Report_TC_Execution_Failure.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_Report_TC_Execution_Failure_lock(_ProjectionRead_Report_TC_Execution_Failure_mutex); - _OpCache_Report_TC_Execution_Failure.insert({param, _OpCache_with_parameter_Report_TC_Execution_Failure}); - } + for(const BTuple<BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::TM_SET >, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL >& param : _trid_14) { + obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_1 = param.projection2(); + BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::TM_SET > _tmp_2 = param.projection1(); + obsw_M001_1::TM_SET _tmp_3 = _tmp_2.projection2(); + obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_4 = _tmp_2.projection1(); - } else { - std::unordered_map<obsw_M001_1::_ProjectionRead_Report_TC_Execution_Failure, obsw_M001_1::_ProjectionWrite_Report_TC_Execution_Failure, obsw_M001_1::_ProjectionRead_Report_TC_Execution_Failure::Hash, obsw_M001_1::_ProjectionRead_Report_TC_Execution_Failure::HashEqual> _OpCache_with_parameter_Report_TC_Execution_Failure = _OpCache_with_parameter_Report_TC_Execution_Failure_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_Report_TC_Execution_Failure.find(readState); - if(writeState_ptr != _OpCache_with_parameter_Report_TC_Execution_Failure.end()) { - obsw_M001_1::_ProjectionWrite_Report_TC_Execution_Failure writeState = writeState_ptr->second; - copiedState._apply_update_for_Report_TC_Execution_Failure(writeState); - } else { - copiedState.Report_TC_Execution_Failure(_tmp_4, _tmp_3, _tmp_1); - obsw_M001_1::_ProjectionWrite_Report_TC_Execution_Failure writeState = copiedState._update_for_Report_TC_Execution_Failure(); - { - std::unique_lock<std::mutex> _ProjectionRead_Report_TC_Execution_Failure_lock(_ProjectionRead_Report_TC_Execution_Failure_mutex); - _OpCache_with_parameter_Report_TC_Execution_Failure.insert({readState, writeState}); - } - } + obsw_M001_1 copiedState = state._copy(); + obsw_M001_1::_ProjectionRead_Report_TC_Execution_Failure readState = state._projected_state_for_Report_TC_Execution_Failure(); + + auto _OpCache_with_parameter_Report_TC_Execution_Failure_ptr = _OpCache_Report_TC_Execution_Failure.find(param); + if(_OpCache_with_parameter_Report_TC_Execution_Failure_ptr == _OpCache_Report_TC_Execution_Failure.end()) { + copiedState.Report_TC_Execution_Failure(_tmp_4, _tmp_3, _tmp_1); + obsw_M001_1::_ProjectionWrite_Report_TC_Execution_Failure writeState = copiedState._update_for_Report_TC_Execution_Failure(); + std::unordered_map<obsw_M001_1::_ProjectionRead_Report_TC_Execution_Failure, obsw_M001_1::_ProjectionWrite_Report_TC_Execution_Failure, obsw_M001_1::_ProjectionRead_Report_TC_Execution_Failure::Hash, obsw_M001_1::_ProjectionRead_Report_TC_Execution_Failure::HashEqual> _OpCache_with_parameter_Report_TC_Execution_Failure; + _OpCache_with_parameter_Report_TC_Execution_Failure.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_Report_TC_Execution_Failure_lock(_ProjectionRead_Report_TC_Execution_Failure_mutex); + _OpCache_Report_TC_Execution_Failure.insert({param, _OpCache_with_parameter_Report_TC_Execution_Failure}); } - copiedState.stateAccessedVia = "Report_TC_Execution_Failure"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<BTuple<BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::TM_SET >, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL >> _trid_14 = _trid_14_ptr->second; - for(const BTuple<BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::TM_SET >, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL >& param : _trid_14) { - obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_1 = param.projection2(); - BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::TM_SET > _tmp_2 = param.projection1(); - obsw_M001_1::TM_SET _tmp_3 = _tmp_2.projection2(); - obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_4 = _tmp_2.projection1(); - - obsw_M001_1 copiedState = state._copy(); - obsw_M001_1::_ProjectionRead_Report_TC_Execution_Failure readState = state._projected_state_for_Report_TC_Execution_Failure(); - - auto _OpCache_with_parameter_Report_TC_Execution_Failure_ptr = _OpCache_Report_TC_Execution_Failure.find(param); - if(_OpCache_with_parameter_Report_TC_Execution_Failure_ptr == _OpCache_Report_TC_Execution_Failure.end()) { + } else { + std::unordered_map<obsw_M001_1::_ProjectionRead_Report_TC_Execution_Failure, obsw_M001_1::_ProjectionWrite_Report_TC_Execution_Failure, obsw_M001_1::_ProjectionRead_Report_TC_Execution_Failure::Hash, obsw_M001_1::_ProjectionRead_Report_TC_Execution_Failure::HashEqual> _OpCache_with_parameter_Report_TC_Execution_Failure = _OpCache_with_parameter_Report_TC_Execution_Failure_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_Report_TC_Execution_Failure.find(readState); + if(writeState_ptr != _OpCache_with_parameter_Report_TC_Execution_Failure.end()) { + obsw_M001_1::_ProjectionWrite_Report_TC_Execution_Failure writeState = writeState_ptr->second; + copiedState._apply_update_for_Report_TC_Execution_Failure(writeState); + } else { copiedState.Report_TC_Execution_Failure(_tmp_4, _tmp_3, _tmp_1); obsw_M001_1::_ProjectionWrite_Report_TC_Execution_Failure writeState = copiedState._update_for_Report_TC_Execution_Failure(); - std::unordered_map<obsw_M001_1::_ProjectionRead_Report_TC_Execution_Failure, obsw_M001_1::_ProjectionWrite_Report_TC_Execution_Failure, obsw_M001_1::_ProjectionRead_Report_TC_Execution_Failure::Hash, obsw_M001_1::_ProjectionRead_Report_TC_Execution_Failure::HashEqual> _OpCache_with_parameter_Report_TC_Execution_Failure; - _OpCache_with_parameter_Report_TC_Execution_Failure.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_Report_TC_Execution_Failure_lock(_ProjectionRead_Report_TC_Execution_Failure_mutex); - _OpCache_Report_TC_Execution_Failure.insert({param, _OpCache_with_parameter_Report_TC_Execution_Failure}); - } - - } else { - std::unordered_map<obsw_M001_1::_ProjectionRead_Report_TC_Execution_Failure, obsw_M001_1::_ProjectionWrite_Report_TC_Execution_Failure, obsw_M001_1::_ProjectionRead_Report_TC_Execution_Failure::Hash, obsw_M001_1::_ProjectionRead_Report_TC_Execution_Failure::HashEqual> _OpCache_with_parameter_Report_TC_Execution_Failure = _OpCache_with_parameter_Report_TC_Execution_Failure_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_Report_TC_Execution_Failure.find(readState); - if(writeState_ptr != _OpCache_with_parameter_Report_TC_Execution_Failure.end()) { - obsw_M001_1::_ProjectionWrite_Report_TC_Execution_Failure writeState = writeState_ptr->second; - copiedState._apply_update_for_Report_TC_Execution_Failure(writeState); - } else { - copiedState.Report_TC_Execution_Failure(_tmp_4, _tmp_3, _tmp_1); - obsw_M001_1::_ProjectionWrite_Report_TC_Execution_Failure writeState = copiedState._update_for_Report_TC_Execution_Failure(); - { - std::unique_lock<std::mutex> _ProjectionRead_Report_TC_Execution_Failure_lock(_ProjectionRead_Report_TC_Execution_Failure_mutex); - _OpCache_with_parameter_Report_TC_Execution_Failure.insert({readState, writeState}); - } + _OpCache_with_parameter_Report_TC_Execution_Failure.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "Report_TC_Execution_Failure"; - result.insert(copiedState); + copiedState.stateAccessedVia = "Report_TC_Execution_Failure"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } obsw_M001_1::_ProjectionRead__tr_Skip_TC_Failure_Report read__tr_Skip_TC_Failure_Report_state = state._projected_state_for__tr_Skip_TC_Failure_Report(); + BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_15; auto _trid_15_ptr = _OpCache_tr_Skip_TC_Failure_Report.find(read__tr_Skip_TC_Failure_Report_state); if(_trid_15_ptr == _OpCache_tr_Skip_TC_Failure_Report.end()) { - BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_15 = state._tr_Skip_TC_Failure_Report(); + _trid_15 = state._tr_Skip_TC_Failure_Report(); { std::unique_lock<std::mutex> _ProjectionRead__tr_Skip_TC_Failure_Report_lock(_ProjectionRead__tr_Skip_TC_Failure_Report_mutex); _OpCache_tr_Skip_TC_Failure_Report.insert({read__tr_Skip_TC_Failure_Report_state, _trid_15}); } - for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_15) { - obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param; - - obsw_M001_1 copiedState = state._copy(); - obsw_M001_1::_ProjectionRead_Skip_TC_Failure_Report readState = state._projected_state_for_Skip_TC_Failure_Report(); + } else { + _trid_15 = _trid_15_ptr->second; + } - auto _OpCache_with_parameter_Skip_TC_Failure_Report_ptr = _OpCache_Skip_TC_Failure_Report.find(param); - if(_OpCache_with_parameter_Skip_TC_Failure_Report_ptr == _OpCache_Skip_TC_Failure_Report.end()) { - copiedState.Skip_TC_Failure_Report(_tmp_1); - obsw_M001_1::_ProjectionWrite_Skip_TC_Failure_Report writeState = copiedState._update_for_Skip_TC_Failure_Report(); - std::unordered_map<obsw_M001_1::_ProjectionRead_Skip_TC_Failure_Report, obsw_M001_1::_ProjectionWrite_Skip_TC_Failure_Report, obsw_M001_1::_ProjectionRead_Skip_TC_Failure_Report::Hash, obsw_M001_1::_ProjectionRead_Skip_TC_Failure_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Failure_Report; - _OpCache_with_parameter_Skip_TC_Failure_Report.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_Skip_TC_Failure_Report_lock(_ProjectionRead_Skip_TC_Failure_Report_mutex); - _OpCache_Skip_TC_Failure_Report.insert({param, _OpCache_with_parameter_Skip_TC_Failure_Report}); - } + for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_15) { + obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param; - } else { - std::unordered_map<obsw_M001_1::_ProjectionRead_Skip_TC_Failure_Report, obsw_M001_1::_ProjectionWrite_Skip_TC_Failure_Report, obsw_M001_1::_ProjectionRead_Skip_TC_Failure_Report::Hash, obsw_M001_1::_ProjectionRead_Skip_TC_Failure_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Failure_Report = _OpCache_with_parameter_Skip_TC_Failure_Report_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_Skip_TC_Failure_Report.find(readState); - if(writeState_ptr != _OpCache_with_parameter_Skip_TC_Failure_Report.end()) { - obsw_M001_1::_ProjectionWrite_Skip_TC_Failure_Report writeState = writeState_ptr->second; - copiedState._apply_update_for_Skip_TC_Failure_Report(writeState); - } else { - copiedState.Skip_TC_Failure_Report(_tmp_1); - obsw_M001_1::_ProjectionWrite_Skip_TC_Failure_Report writeState = copiedState._update_for_Skip_TC_Failure_Report(); - { - std::unique_lock<std::mutex> _ProjectionRead_Skip_TC_Failure_Report_lock(_ProjectionRead_Skip_TC_Failure_Report_mutex); - _OpCache_with_parameter_Skip_TC_Failure_Report.insert({readState, writeState}); - } - } + obsw_M001_1 copiedState = state._copy(); + obsw_M001_1::_ProjectionRead_Skip_TC_Failure_Report readState = state._projected_state_for_Skip_TC_Failure_Report(); + + auto _OpCache_with_parameter_Skip_TC_Failure_Report_ptr = _OpCache_Skip_TC_Failure_Report.find(param); + if(_OpCache_with_parameter_Skip_TC_Failure_Report_ptr == _OpCache_Skip_TC_Failure_Report.end()) { + copiedState.Skip_TC_Failure_Report(_tmp_1); + obsw_M001_1::_ProjectionWrite_Skip_TC_Failure_Report writeState = copiedState._update_for_Skip_TC_Failure_Report(); + std::unordered_map<obsw_M001_1::_ProjectionRead_Skip_TC_Failure_Report, obsw_M001_1::_ProjectionWrite_Skip_TC_Failure_Report, obsw_M001_1::_ProjectionRead_Skip_TC_Failure_Report::Hash, obsw_M001_1::_ProjectionRead_Skip_TC_Failure_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Failure_Report; + _OpCache_with_parameter_Skip_TC_Failure_Report.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_Skip_TC_Failure_Report_lock(_ProjectionRead_Skip_TC_Failure_Report_mutex); + _OpCache_Skip_TC_Failure_Report.insert({param, _OpCache_with_parameter_Skip_TC_Failure_Report}); } - copiedState.stateAccessedVia = "Skip_TC_Failure_Report"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_15 = _trid_15_ptr->second; - for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_15) { - obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param; - - obsw_M001_1 copiedState = state._copy(); - obsw_M001_1::_ProjectionRead_Skip_TC_Failure_Report readState = state._projected_state_for_Skip_TC_Failure_Report(); - - auto _OpCache_with_parameter_Skip_TC_Failure_Report_ptr = _OpCache_Skip_TC_Failure_Report.find(param); - if(_OpCache_with_parameter_Skip_TC_Failure_Report_ptr == _OpCache_Skip_TC_Failure_Report.end()) { + } else { + std::unordered_map<obsw_M001_1::_ProjectionRead_Skip_TC_Failure_Report, obsw_M001_1::_ProjectionWrite_Skip_TC_Failure_Report, obsw_M001_1::_ProjectionRead_Skip_TC_Failure_Report::Hash, obsw_M001_1::_ProjectionRead_Skip_TC_Failure_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Failure_Report = _OpCache_with_parameter_Skip_TC_Failure_Report_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_Skip_TC_Failure_Report.find(readState); + if(writeState_ptr != _OpCache_with_parameter_Skip_TC_Failure_Report.end()) { + obsw_M001_1::_ProjectionWrite_Skip_TC_Failure_Report writeState = writeState_ptr->second; + copiedState._apply_update_for_Skip_TC_Failure_Report(writeState); + } else { copiedState.Skip_TC_Failure_Report(_tmp_1); obsw_M001_1::_ProjectionWrite_Skip_TC_Failure_Report writeState = copiedState._update_for_Skip_TC_Failure_Report(); - std::unordered_map<obsw_M001_1::_ProjectionRead_Skip_TC_Failure_Report, obsw_M001_1::_ProjectionWrite_Skip_TC_Failure_Report, obsw_M001_1::_ProjectionRead_Skip_TC_Failure_Report::Hash, obsw_M001_1::_ProjectionRead_Skip_TC_Failure_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Failure_Report; - _OpCache_with_parameter_Skip_TC_Failure_Report.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_Skip_TC_Failure_Report_lock(_ProjectionRead_Skip_TC_Failure_Report_mutex); - _OpCache_Skip_TC_Failure_Report.insert({param, _OpCache_with_parameter_Skip_TC_Failure_Report}); - } - - } else { - std::unordered_map<obsw_M001_1::_ProjectionRead_Skip_TC_Failure_Report, obsw_M001_1::_ProjectionWrite_Skip_TC_Failure_Report, obsw_M001_1::_ProjectionRead_Skip_TC_Failure_Report::Hash, obsw_M001_1::_ProjectionRead_Skip_TC_Failure_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Failure_Report = _OpCache_with_parameter_Skip_TC_Failure_Report_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_Skip_TC_Failure_Report.find(readState); - if(writeState_ptr != _OpCache_with_parameter_Skip_TC_Failure_Report.end()) { - obsw_M001_1::_ProjectionWrite_Skip_TC_Failure_Report writeState = writeState_ptr->second; - copiedState._apply_update_for_Skip_TC_Failure_Report(writeState); - } else { - copiedState.Skip_TC_Failure_Report(_tmp_1); - obsw_M001_1::_ProjectionWrite_Skip_TC_Failure_Report writeState = copiedState._update_for_Skip_TC_Failure_Report(); - { - std::unique_lock<std::mutex> _ProjectionRead_Skip_TC_Failure_Report_lock(_ProjectionRead_Skip_TC_Failure_Report_mutex); - _OpCache_with_parameter_Skip_TC_Failure_Report.insert({readState, writeState}); - } + _OpCache_with_parameter_Skip_TC_Failure_Report.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "Skip_TC_Failure_Report"; - result.insert(copiedState); + copiedState.stateAccessedVia = "Skip_TC_Failure_Report"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } obsw_M001_1::_ProjectionRead__tr_Drop_TC read__tr_Drop_TC_state = state._projected_state_for__tr_Drop_TC(); + BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_16; auto _trid_16_ptr = _OpCache_tr_Drop_TC.find(read__tr_Drop_TC_state); if(_trid_16_ptr == _OpCache_tr_Drop_TC.end()) { - BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_16 = state._tr_Drop_TC(); - { - std::unique_lock<std::mutex> _ProjectionRead__tr_Drop_TC_lock(_ProjectionRead__tr_Drop_TC_mutex); - _OpCache_tr_Drop_TC.insert({read__tr_Drop_TC_state, _trid_16}); - } - for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_16) { - obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param; - - obsw_M001_1 copiedState = state._copy(); - obsw_M001_1::_ProjectionRead_Drop_TC readState = state._projected_state_for_Drop_TC(); - - auto _OpCache_with_parameter_Drop_TC_ptr = _OpCache_Drop_TC.find(param); - if(_OpCache_with_parameter_Drop_TC_ptr == _OpCache_Drop_TC.end()) { - copiedState.Drop_TC(_tmp_1); - obsw_M001_1::_ProjectionWrite_Drop_TC writeState = copiedState._update_for_Drop_TC(); - std::unordered_map<obsw_M001_1::_ProjectionRead_Drop_TC, obsw_M001_1::_ProjectionWrite_Drop_TC, obsw_M001_1::_ProjectionRead_Drop_TC::Hash, obsw_M001_1::_ProjectionRead_Drop_TC::HashEqual> _OpCache_with_parameter_Drop_TC; - _OpCache_with_parameter_Drop_TC.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_Drop_TC_lock(_ProjectionRead_Drop_TC_mutex); - _OpCache_Drop_TC.insert({param, _OpCache_with_parameter_Drop_TC}); - } - - } else { - std::unordered_map<obsw_M001_1::_ProjectionRead_Drop_TC, obsw_M001_1::_ProjectionWrite_Drop_TC, obsw_M001_1::_ProjectionRead_Drop_TC::Hash, obsw_M001_1::_ProjectionRead_Drop_TC::HashEqual> _OpCache_with_parameter_Drop_TC = _OpCache_with_parameter_Drop_TC_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_Drop_TC.find(readState); - if(writeState_ptr != _OpCache_with_parameter_Drop_TC.end()) { - obsw_M001_1::_ProjectionWrite_Drop_TC writeState = writeState_ptr->second; - copiedState._apply_update_for_Drop_TC(writeState); - } else { - copiedState.Drop_TC(_tmp_1); - obsw_M001_1::_ProjectionWrite_Drop_TC writeState = copiedState._update_for_Drop_TC(); - { - std::unique_lock<std::mutex> _ProjectionRead_Drop_TC_lock(_ProjectionRead_Drop_TC_mutex); - _OpCache_with_parameter_Drop_TC.insert({readState, writeState}); - } - } - } - - copiedState.stateAccessedVia = "Drop_TC"; - result.insert(copiedState); - transitions += 1; + _trid_16 = state._tr_Drop_TC(); + { + std::unique_lock<std::mutex> _ProjectionRead__tr_Drop_TC_lock(_ProjectionRead__tr_Drop_TC_mutex); + _OpCache_tr_Drop_TC.insert({read__tr_Drop_TC_state, _trid_16}); } } else { - BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_16 = _trid_16_ptr->second; - for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_16) { - obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param; + _trid_16 = _trid_16_ptr->second; + } - obsw_M001_1 copiedState = state._copy(); - obsw_M001_1::_ProjectionRead_Drop_TC readState = state._projected_state_for_Drop_TC(); + for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_16) { + obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param; + + obsw_M001_1 copiedState = state._copy(); + obsw_M001_1::_ProjectionRead_Drop_TC readState = state._projected_state_for_Drop_TC(); + + auto _OpCache_with_parameter_Drop_TC_ptr = _OpCache_Drop_TC.find(param); + if(_OpCache_with_parameter_Drop_TC_ptr == _OpCache_Drop_TC.end()) { + copiedState.Drop_TC(_tmp_1); + obsw_M001_1::_ProjectionWrite_Drop_TC writeState = copiedState._update_for_Drop_TC(); + std::unordered_map<obsw_M001_1::_ProjectionRead_Drop_TC, obsw_M001_1::_ProjectionWrite_Drop_TC, obsw_M001_1::_ProjectionRead_Drop_TC::Hash, obsw_M001_1::_ProjectionRead_Drop_TC::HashEqual> _OpCache_with_parameter_Drop_TC; + _OpCache_with_parameter_Drop_TC.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_Drop_TC_lock(_ProjectionRead_Drop_TC_mutex); + _OpCache_Drop_TC.insert({param, _OpCache_with_parameter_Drop_TC}); + } - auto _OpCache_with_parameter_Drop_TC_ptr = _OpCache_Drop_TC.find(param); - if(_OpCache_with_parameter_Drop_TC_ptr == _OpCache_Drop_TC.end()) { + } else { + std::unordered_map<obsw_M001_1::_ProjectionRead_Drop_TC, obsw_M001_1::_ProjectionWrite_Drop_TC, obsw_M001_1::_ProjectionRead_Drop_TC::Hash, obsw_M001_1::_ProjectionRead_Drop_TC::HashEqual> _OpCache_with_parameter_Drop_TC = _OpCache_with_parameter_Drop_TC_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_Drop_TC.find(readState); + if(writeState_ptr != _OpCache_with_parameter_Drop_TC.end()) { + obsw_M001_1::_ProjectionWrite_Drop_TC writeState = writeState_ptr->second; + copiedState._apply_update_for_Drop_TC(writeState); + } else { copiedState.Drop_TC(_tmp_1); obsw_M001_1::_ProjectionWrite_Drop_TC writeState = copiedState._update_for_Drop_TC(); - std::unordered_map<obsw_M001_1::_ProjectionRead_Drop_TC, obsw_M001_1::_ProjectionWrite_Drop_TC, obsw_M001_1::_ProjectionRead_Drop_TC::Hash, obsw_M001_1::_ProjectionRead_Drop_TC::HashEqual> _OpCache_with_parameter_Drop_TC; - _OpCache_with_parameter_Drop_TC.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_Drop_TC_lock(_ProjectionRead_Drop_TC_mutex); - _OpCache_Drop_TC.insert({param, _OpCache_with_parameter_Drop_TC}); - } - - } else { - std::unordered_map<obsw_M001_1::_ProjectionRead_Drop_TC, obsw_M001_1::_ProjectionWrite_Drop_TC, obsw_M001_1::_ProjectionRead_Drop_TC::Hash, obsw_M001_1::_ProjectionRead_Drop_TC::HashEqual> _OpCache_with_parameter_Drop_TC = _OpCache_with_parameter_Drop_TC_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_Drop_TC.find(readState); - if(writeState_ptr != _OpCache_with_parameter_Drop_TC.end()) { - obsw_M001_1::_ProjectionWrite_Drop_TC writeState = writeState_ptr->second; - copiedState._apply_update_for_Drop_TC(writeState); - } else { - copiedState.Drop_TC(_tmp_1); - obsw_M001_1::_ProjectionWrite_Drop_TC writeState = copiedState._update_for_Drop_TC(); - { - std::unique_lock<std::mutex> _ProjectionRead_Drop_TC_lock(_ProjectionRead_Drop_TC_mutex); - _OpCache_with_parameter_Drop_TC.insert({readState, writeState}); - } + _OpCache_with_parameter_Drop_TC.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "Drop_TC"; - result.insert(copiedState); + copiedState.stateAccessedVia = "Drop_TC"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } obsw_M001_1::_ProjectionRead__tr_Produce_TM read__tr_Produce_TM_state = state._projected_state_for__tr_Produce_TM(); + BSet<BTuple<obsw_M001_1::TM_SET, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL >> _trid_17; auto _trid_17_ptr = _OpCache_tr_Produce_TM.find(read__tr_Produce_TM_state); if(_trid_17_ptr == _OpCache_tr_Produce_TM.end()) { - BSet<BTuple<obsw_M001_1::TM_SET, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL >> _trid_17 = state._tr_Produce_TM(); + _trid_17 = state._tr_Produce_TM(); { std::unique_lock<std::mutex> _ProjectionRead__tr_Produce_TM_lock(_ProjectionRead__tr_Produce_TM_mutex); _OpCache_tr_Produce_TM.insert({read__tr_Produce_TM_state, _trid_17}); } - for(const BTuple<obsw_M001_1::TM_SET, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL >& param : _trid_17) { - obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_1 = param.projection2(); - obsw_M001_1::TM_SET _tmp_2 = param.projection1(); - - obsw_M001_1 copiedState = state._copy(); - obsw_M001_1::_ProjectionRead_Produce_TM readState = state._projected_state_for_Produce_TM(); + } else { + _trid_17 = _trid_17_ptr->second; + } - auto _OpCache_with_parameter_Produce_TM_ptr = _OpCache_Produce_TM.find(param); - if(_OpCache_with_parameter_Produce_TM_ptr == _OpCache_Produce_TM.end()) { - copiedState.Produce_TM(_tmp_2, _tmp_1); - obsw_M001_1::_ProjectionWrite_Produce_TM writeState = copiedState._update_for_Produce_TM(); - std::unordered_map<obsw_M001_1::_ProjectionRead_Produce_TM, obsw_M001_1::_ProjectionWrite_Produce_TM, obsw_M001_1::_ProjectionRead_Produce_TM::Hash, obsw_M001_1::_ProjectionRead_Produce_TM::HashEqual> _OpCache_with_parameter_Produce_TM; - _OpCache_with_parameter_Produce_TM.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_Produce_TM_lock(_ProjectionRead_Produce_TM_mutex); - _OpCache_Produce_TM.insert({param, _OpCache_with_parameter_Produce_TM}); - } + for(const BTuple<obsw_M001_1::TM_SET, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL >& param : _trid_17) { + obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_1 = param.projection2(); + obsw_M001_1::TM_SET _tmp_2 = param.projection1(); - } else { - std::unordered_map<obsw_M001_1::_ProjectionRead_Produce_TM, obsw_M001_1::_ProjectionWrite_Produce_TM, obsw_M001_1::_ProjectionRead_Produce_TM::Hash, obsw_M001_1::_ProjectionRead_Produce_TM::HashEqual> _OpCache_with_parameter_Produce_TM = _OpCache_with_parameter_Produce_TM_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_Produce_TM.find(readState); - if(writeState_ptr != _OpCache_with_parameter_Produce_TM.end()) { - obsw_M001_1::_ProjectionWrite_Produce_TM writeState = writeState_ptr->second; - copiedState._apply_update_for_Produce_TM(writeState); - } else { - copiedState.Produce_TM(_tmp_2, _tmp_1); - obsw_M001_1::_ProjectionWrite_Produce_TM writeState = copiedState._update_for_Produce_TM(); - { - std::unique_lock<std::mutex> _ProjectionRead_Produce_TM_lock(_ProjectionRead_Produce_TM_mutex); - _OpCache_with_parameter_Produce_TM.insert({readState, writeState}); - } - } + obsw_M001_1 copiedState = state._copy(); + obsw_M001_1::_ProjectionRead_Produce_TM readState = state._projected_state_for_Produce_TM(); + + auto _OpCache_with_parameter_Produce_TM_ptr = _OpCache_Produce_TM.find(param); + if(_OpCache_with_parameter_Produce_TM_ptr == _OpCache_Produce_TM.end()) { + copiedState.Produce_TM(_tmp_2, _tmp_1); + obsw_M001_1::_ProjectionWrite_Produce_TM writeState = copiedState._update_for_Produce_TM(); + std::unordered_map<obsw_M001_1::_ProjectionRead_Produce_TM, obsw_M001_1::_ProjectionWrite_Produce_TM, obsw_M001_1::_ProjectionRead_Produce_TM::Hash, obsw_M001_1::_ProjectionRead_Produce_TM::HashEqual> _OpCache_with_parameter_Produce_TM; + _OpCache_with_parameter_Produce_TM.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_Produce_TM_lock(_ProjectionRead_Produce_TM_mutex); + _OpCache_Produce_TM.insert({param, _OpCache_with_parameter_Produce_TM}); } - copiedState.stateAccessedVia = "Produce_TM"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<BTuple<obsw_M001_1::TM_SET, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL >> _trid_17 = _trid_17_ptr->second; - for(const BTuple<obsw_M001_1::TM_SET, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL >& param : _trid_17) { - obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_1 = param.projection2(); - obsw_M001_1::TM_SET _tmp_2 = param.projection1(); - - obsw_M001_1 copiedState = state._copy(); - obsw_M001_1::_ProjectionRead_Produce_TM readState = state._projected_state_for_Produce_TM(); - - auto _OpCache_with_parameter_Produce_TM_ptr = _OpCache_Produce_TM.find(param); - if(_OpCache_with_parameter_Produce_TM_ptr == _OpCache_Produce_TM.end()) { + } else { + std::unordered_map<obsw_M001_1::_ProjectionRead_Produce_TM, obsw_M001_1::_ProjectionWrite_Produce_TM, obsw_M001_1::_ProjectionRead_Produce_TM::Hash, obsw_M001_1::_ProjectionRead_Produce_TM::HashEqual> _OpCache_with_parameter_Produce_TM = _OpCache_with_parameter_Produce_TM_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_Produce_TM.find(readState); + if(writeState_ptr != _OpCache_with_parameter_Produce_TM.end()) { + obsw_M001_1::_ProjectionWrite_Produce_TM writeState = writeState_ptr->second; + copiedState._apply_update_for_Produce_TM(writeState); + } else { copiedState.Produce_TM(_tmp_2, _tmp_1); obsw_M001_1::_ProjectionWrite_Produce_TM writeState = copiedState._update_for_Produce_TM(); - std::unordered_map<obsw_M001_1::_ProjectionRead_Produce_TM, obsw_M001_1::_ProjectionWrite_Produce_TM, obsw_M001_1::_ProjectionRead_Produce_TM::Hash, obsw_M001_1::_ProjectionRead_Produce_TM::HashEqual> _OpCache_with_parameter_Produce_TM; - _OpCache_with_parameter_Produce_TM.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_Produce_TM_lock(_ProjectionRead_Produce_TM_mutex); - _OpCache_Produce_TM.insert({param, _OpCache_with_parameter_Produce_TM}); - } - - } else { - std::unordered_map<obsw_M001_1::_ProjectionRead_Produce_TM, obsw_M001_1::_ProjectionWrite_Produce_TM, obsw_M001_1::_ProjectionRead_Produce_TM::Hash, obsw_M001_1::_ProjectionRead_Produce_TM::HashEqual> _OpCache_with_parameter_Produce_TM = _OpCache_with_parameter_Produce_TM_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_Produce_TM.find(readState); - if(writeState_ptr != _OpCache_with_parameter_Produce_TM.end()) { - obsw_M001_1::_ProjectionWrite_Produce_TM writeState = writeState_ptr->second; - copiedState._apply_update_for_Produce_TM(writeState); - } else { - copiedState.Produce_TM(_tmp_2, _tmp_1); - obsw_M001_1::_ProjectionWrite_Produce_TM writeState = copiedState._update_for_Produce_TM(); - { - std::unique_lock<std::mutex> _ProjectionRead_Produce_TM_lock(_ProjectionRead_Produce_TM_mutex); - _OpCache_with_parameter_Produce_TM.insert({readState, writeState}); - } + _OpCache_with_parameter_Produce_TM.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "Produce_TM"; - result.insert(copiedState); + copiedState.stateAccessedVia = "Produce_TM"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } obsw_M001_1::_ProjectionRead__tr_Pass_TM read__tr_Pass_TM_state = state._projected_state_for__tr_Pass_TM(); + BSet<BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_BUFFER >> _trid_18; auto _trid_18_ptr = _OpCache_tr_Pass_TM.find(read__tr_Pass_TM_state); if(_trid_18_ptr == _OpCache_tr_Pass_TM.end()) { - BSet<BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_BUFFER >> _trid_18 = state._tr_Pass_TM(); + _trid_18 = state._tr_Pass_TM(); { std::unique_lock<std::mutex> _ProjectionRead__tr_Pass_TM_lock(_ProjectionRead__tr_Pass_TM_mutex); _OpCache_tr_Pass_TM.insert({read__tr_Pass_TM_state, _trid_18}); } - for(const BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_BUFFER >& param : _trid_18) { - obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_BUFFER _tmp_1 = param.projection2(); - obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_2 = param.projection1(); - - obsw_M001_1 copiedState = state._copy(); - obsw_M001_1::_ProjectionRead_Pass_TM readState = state._projected_state_for_Pass_TM(); + } else { + _trid_18 = _trid_18_ptr->second; + } - auto _OpCache_with_parameter_Pass_TM_ptr = _OpCache_Pass_TM.find(param); - if(_OpCache_with_parameter_Pass_TM_ptr == _OpCache_Pass_TM.end()) { - copiedState.Pass_TM(_tmp_2, _tmp_1); - obsw_M001_1::_ProjectionWrite_Pass_TM writeState = copiedState._update_for_Pass_TM(); - std::unordered_map<obsw_M001_1::_ProjectionRead_Pass_TM, obsw_M001_1::_ProjectionWrite_Pass_TM, obsw_M001_1::_ProjectionRead_Pass_TM::Hash, obsw_M001_1::_ProjectionRead_Pass_TM::HashEqual> _OpCache_with_parameter_Pass_TM; - _OpCache_with_parameter_Pass_TM.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_Pass_TM_lock(_ProjectionRead_Pass_TM_mutex); - _OpCache_Pass_TM.insert({param, _OpCache_with_parameter_Pass_TM}); - } + for(const BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_BUFFER >& param : _trid_18) { + obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_BUFFER _tmp_1 = param.projection2(); + obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_2 = param.projection1(); - } else { - std::unordered_map<obsw_M001_1::_ProjectionRead_Pass_TM, obsw_M001_1::_ProjectionWrite_Pass_TM, obsw_M001_1::_ProjectionRead_Pass_TM::Hash, obsw_M001_1::_ProjectionRead_Pass_TM::HashEqual> _OpCache_with_parameter_Pass_TM = _OpCache_with_parameter_Pass_TM_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_Pass_TM.find(readState); - if(writeState_ptr != _OpCache_with_parameter_Pass_TM.end()) { - obsw_M001_1::_ProjectionWrite_Pass_TM writeState = writeState_ptr->second; - copiedState._apply_update_for_Pass_TM(writeState); - } else { - copiedState.Pass_TM(_tmp_2, _tmp_1); - obsw_M001_1::_ProjectionWrite_Pass_TM writeState = copiedState._update_for_Pass_TM(); - { - std::unique_lock<std::mutex> _ProjectionRead_Pass_TM_lock(_ProjectionRead_Pass_TM_mutex); - _OpCache_with_parameter_Pass_TM.insert({readState, writeState}); - } - } + obsw_M001_1 copiedState = state._copy(); + obsw_M001_1::_ProjectionRead_Pass_TM readState = state._projected_state_for_Pass_TM(); + + auto _OpCache_with_parameter_Pass_TM_ptr = _OpCache_Pass_TM.find(param); + if(_OpCache_with_parameter_Pass_TM_ptr == _OpCache_Pass_TM.end()) { + copiedState.Pass_TM(_tmp_2, _tmp_1); + obsw_M001_1::_ProjectionWrite_Pass_TM writeState = copiedState._update_for_Pass_TM(); + std::unordered_map<obsw_M001_1::_ProjectionRead_Pass_TM, obsw_M001_1::_ProjectionWrite_Pass_TM, obsw_M001_1::_ProjectionRead_Pass_TM::Hash, obsw_M001_1::_ProjectionRead_Pass_TM::HashEqual> _OpCache_with_parameter_Pass_TM; + _OpCache_with_parameter_Pass_TM.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_Pass_TM_lock(_ProjectionRead_Pass_TM_mutex); + _OpCache_Pass_TM.insert({param, _OpCache_with_parameter_Pass_TM}); } - copiedState.stateAccessedVia = "Pass_TM"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_BUFFER >> _trid_18 = _trid_18_ptr->second; - for(const BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_BUFFER >& param : _trid_18) { - obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_BUFFER _tmp_1 = param.projection2(); - obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_2 = param.projection1(); - - obsw_M001_1 copiedState = state._copy(); - obsw_M001_1::_ProjectionRead_Pass_TM readState = state._projected_state_for_Pass_TM(); - - auto _OpCache_with_parameter_Pass_TM_ptr = _OpCache_Pass_TM.find(param); - if(_OpCache_with_parameter_Pass_TM_ptr == _OpCache_Pass_TM.end()) { + } else { + std::unordered_map<obsw_M001_1::_ProjectionRead_Pass_TM, obsw_M001_1::_ProjectionWrite_Pass_TM, obsw_M001_1::_ProjectionRead_Pass_TM::Hash, obsw_M001_1::_ProjectionRead_Pass_TM::HashEqual> _OpCache_with_parameter_Pass_TM = _OpCache_with_parameter_Pass_TM_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_Pass_TM.find(readState); + if(writeState_ptr != _OpCache_with_parameter_Pass_TM.end()) { + obsw_M001_1::_ProjectionWrite_Pass_TM writeState = writeState_ptr->second; + copiedState._apply_update_for_Pass_TM(writeState); + } else { copiedState.Pass_TM(_tmp_2, _tmp_1); obsw_M001_1::_ProjectionWrite_Pass_TM writeState = copiedState._update_for_Pass_TM(); - std::unordered_map<obsw_M001_1::_ProjectionRead_Pass_TM, obsw_M001_1::_ProjectionWrite_Pass_TM, obsw_M001_1::_ProjectionRead_Pass_TM::Hash, obsw_M001_1::_ProjectionRead_Pass_TM::HashEqual> _OpCache_with_parameter_Pass_TM; - _OpCache_with_parameter_Pass_TM.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_Pass_TM_lock(_ProjectionRead_Pass_TM_mutex); - _OpCache_Pass_TM.insert({param, _OpCache_with_parameter_Pass_TM}); - } - - } else { - std::unordered_map<obsw_M001_1::_ProjectionRead_Pass_TM, obsw_M001_1::_ProjectionWrite_Pass_TM, obsw_M001_1::_ProjectionRead_Pass_TM::Hash, obsw_M001_1::_ProjectionRead_Pass_TM::HashEqual> _OpCache_with_parameter_Pass_TM = _OpCache_with_parameter_Pass_TM_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_Pass_TM.find(readState); - if(writeState_ptr != _OpCache_with_parameter_Pass_TM.end()) { - obsw_M001_1::_ProjectionWrite_Pass_TM writeState = writeState_ptr->second; - copiedState._apply_update_for_Pass_TM(writeState); - } else { - copiedState.Pass_TM(_tmp_2, _tmp_1); - obsw_M001_1::_ProjectionWrite_Pass_TM writeState = copiedState._update_for_Pass_TM(); - { - std::unique_lock<std::mutex> _ProjectionRead_Pass_TM_lock(_ProjectionRead_Pass_TM_mutex); - _OpCache_with_parameter_Pass_TM.insert({readState, writeState}); - } + _OpCache_with_parameter_Pass_TM.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "Pass_TM"; - result.insert(copiedState); + copiedState.stateAccessedVia = "Pass_TM"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } obsw_M001_1::_ProjectionRead__tr_Cancel_TM read__tr_Cancel_TM_state = state._projected_state_for__tr_Cancel_TM(); + BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL> _trid_19; auto _trid_19_ptr = _OpCache_tr_Cancel_TM.find(read__tr_Cancel_TM_state); if(_trid_19_ptr == _OpCache_tr_Cancel_TM.end()) { - BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL> _trid_19 = state._tr_Cancel_TM(); + _trid_19 = state._tr_Cancel_TM(); { std::unique_lock<std::mutex> _ProjectionRead__tr_Cancel_TM_lock(_ProjectionRead__tr_Cancel_TM_mutex); _OpCache_tr_Cancel_TM.insert({read__tr_Cancel_TM_state, _trid_19}); } - for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL& param : _trid_19) { - obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_1 = param; - - obsw_M001_1 copiedState = state._copy(); - obsw_M001_1::_ProjectionRead_Cancel_TM readState = state._projected_state_for_Cancel_TM(); + } else { + _trid_19 = _trid_19_ptr->second; + } - auto _OpCache_with_parameter_Cancel_TM_ptr = _OpCache_Cancel_TM.find(param); - if(_OpCache_with_parameter_Cancel_TM_ptr == _OpCache_Cancel_TM.end()) { - copiedState.Cancel_TM(_tmp_1); - obsw_M001_1::_ProjectionWrite_Cancel_TM writeState = copiedState._update_for_Cancel_TM(); - std::unordered_map<obsw_M001_1::_ProjectionRead_Cancel_TM, obsw_M001_1::_ProjectionWrite_Cancel_TM, obsw_M001_1::_ProjectionRead_Cancel_TM::Hash, obsw_M001_1::_ProjectionRead_Cancel_TM::HashEqual> _OpCache_with_parameter_Cancel_TM; - _OpCache_with_parameter_Cancel_TM.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_Cancel_TM_lock(_ProjectionRead_Cancel_TM_mutex); - _OpCache_Cancel_TM.insert({param, _OpCache_with_parameter_Cancel_TM}); - } + for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL& param : _trid_19) { + obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_1 = param; - } else { - std::unordered_map<obsw_M001_1::_ProjectionRead_Cancel_TM, obsw_M001_1::_ProjectionWrite_Cancel_TM, obsw_M001_1::_ProjectionRead_Cancel_TM::Hash, obsw_M001_1::_ProjectionRead_Cancel_TM::HashEqual> _OpCache_with_parameter_Cancel_TM = _OpCache_with_parameter_Cancel_TM_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_Cancel_TM.find(readState); - if(writeState_ptr != _OpCache_with_parameter_Cancel_TM.end()) { - obsw_M001_1::_ProjectionWrite_Cancel_TM writeState = writeState_ptr->second; - copiedState._apply_update_for_Cancel_TM(writeState); - } else { - copiedState.Cancel_TM(_tmp_1); - obsw_M001_1::_ProjectionWrite_Cancel_TM writeState = copiedState._update_for_Cancel_TM(); - { - std::unique_lock<std::mutex> _ProjectionRead_Cancel_TM_lock(_ProjectionRead_Cancel_TM_mutex); - _OpCache_with_parameter_Cancel_TM.insert({readState, writeState}); - } - } + obsw_M001_1 copiedState = state._copy(); + obsw_M001_1::_ProjectionRead_Cancel_TM readState = state._projected_state_for_Cancel_TM(); + + auto _OpCache_with_parameter_Cancel_TM_ptr = _OpCache_Cancel_TM.find(param); + if(_OpCache_with_parameter_Cancel_TM_ptr == _OpCache_Cancel_TM.end()) { + copiedState.Cancel_TM(_tmp_1); + obsw_M001_1::_ProjectionWrite_Cancel_TM writeState = copiedState._update_for_Cancel_TM(); + std::unordered_map<obsw_M001_1::_ProjectionRead_Cancel_TM, obsw_M001_1::_ProjectionWrite_Cancel_TM, obsw_M001_1::_ProjectionRead_Cancel_TM::Hash, obsw_M001_1::_ProjectionRead_Cancel_TM::HashEqual> _OpCache_with_parameter_Cancel_TM; + _OpCache_with_parameter_Cancel_TM.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_Cancel_TM_lock(_ProjectionRead_Cancel_TM_mutex); + _OpCache_Cancel_TM.insert({param, _OpCache_with_parameter_Cancel_TM}); } - copiedState.stateAccessedVia = "Cancel_TM"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL> _trid_19 = _trid_19_ptr->second; - for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL& param : _trid_19) { - obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_1 = param; - - obsw_M001_1 copiedState = state._copy(); - obsw_M001_1::_ProjectionRead_Cancel_TM readState = state._projected_state_for_Cancel_TM(); - - auto _OpCache_with_parameter_Cancel_TM_ptr = _OpCache_Cancel_TM.find(param); - if(_OpCache_with_parameter_Cancel_TM_ptr == _OpCache_Cancel_TM.end()) { + } else { + std::unordered_map<obsw_M001_1::_ProjectionRead_Cancel_TM, obsw_M001_1::_ProjectionWrite_Cancel_TM, obsw_M001_1::_ProjectionRead_Cancel_TM::Hash, obsw_M001_1::_ProjectionRead_Cancel_TM::HashEqual> _OpCache_with_parameter_Cancel_TM = _OpCache_with_parameter_Cancel_TM_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_Cancel_TM.find(readState); + if(writeState_ptr != _OpCache_with_parameter_Cancel_TM.end()) { + obsw_M001_1::_ProjectionWrite_Cancel_TM writeState = writeState_ptr->second; + copiedState._apply_update_for_Cancel_TM(writeState); + } else { copiedState.Cancel_TM(_tmp_1); obsw_M001_1::_ProjectionWrite_Cancel_TM writeState = copiedState._update_for_Cancel_TM(); - std::unordered_map<obsw_M001_1::_ProjectionRead_Cancel_TM, obsw_M001_1::_ProjectionWrite_Cancel_TM, obsw_M001_1::_ProjectionRead_Cancel_TM::Hash, obsw_M001_1::_ProjectionRead_Cancel_TM::HashEqual> _OpCache_with_parameter_Cancel_TM; - _OpCache_with_parameter_Cancel_TM.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_Cancel_TM_lock(_ProjectionRead_Cancel_TM_mutex); - _OpCache_Cancel_TM.insert({param, _OpCache_with_parameter_Cancel_TM}); - } - - } else { - std::unordered_map<obsw_M001_1::_ProjectionRead_Cancel_TM, obsw_M001_1::_ProjectionWrite_Cancel_TM, obsw_M001_1::_ProjectionRead_Cancel_TM::Hash, obsw_M001_1::_ProjectionRead_Cancel_TM::HashEqual> _OpCache_with_parameter_Cancel_TM = _OpCache_with_parameter_Cancel_TM_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_Cancel_TM.find(readState); - if(writeState_ptr != _OpCache_with_parameter_Cancel_TM.end()) { - obsw_M001_1::_ProjectionWrite_Cancel_TM writeState = writeState_ptr->second; - copiedState._apply_update_for_Cancel_TM(writeState); - } else { - copiedState.Cancel_TM(_tmp_1); - obsw_M001_1::_ProjectionWrite_Cancel_TM writeState = copiedState._update_for_Cancel_TM(); - { - std::unique_lock<std::mutex> _ProjectionRead_Cancel_TM_lock(_ProjectionRead_Cancel_TM_mutex); - _OpCache_with_parameter_Cancel_TM.insert({readState, writeState}); - } + _OpCache_with_parameter_Cancel_TM.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "Cancel_TM"; - result.insert(copiedState); + copiedState.stateAccessedVia = "Cancel_TM"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } obsw_M001_1::_ProjectionRead__tr_Drop_TM read__tr_Drop_TM_state = state._projected_state_for__tr_Drop_TM(); + BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL> _trid_20; auto _trid_20_ptr = _OpCache_tr_Drop_TM.find(read__tr_Drop_TM_state); if(_trid_20_ptr == _OpCache_tr_Drop_TM.end()) { - BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL> _trid_20 = state._tr_Drop_TM(); + _trid_20 = state._tr_Drop_TM(); { std::unique_lock<std::mutex> _ProjectionRead__tr_Drop_TM_lock(_ProjectionRead__tr_Drop_TM_mutex); _OpCache_tr_Drop_TM.insert({read__tr_Drop_TM_state, _trid_20}); } - for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL& param : _trid_20) { - obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_1 = param; - - obsw_M001_1 copiedState = state._copy(); - obsw_M001_1::_ProjectionRead_Drop_TM readState = state._projected_state_for_Drop_TM(); + } else { + _trid_20 = _trid_20_ptr->second; + } - auto _OpCache_with_parameter_Drop_TM_ptr = _OpCache_Drop_TM.find(param); - if(_OpCache_with_parameter_Drop_TM_ptr == _OpCache_Drop_TM.end()) { - copiedState.Drop_TM(_tmp_1); - obsw_M001_1::_ProjectionWrite_Drop_TM writeState = copiedState._update_for_Drop_TM(); - std::unordered_map<obsw_M001_1::_ProjectionRead_Drop_TM, obsw_M001_1::_ProjectionWrite_Drop_TM, obsw_M001_1::_ProjectionRead_Drop_TM::Hash, obsw_M001_1::_ProjectionRead_Drop_TM::HashEqual> _OpCache_with_parameter_Drop_TM; - _OpCache_with_parameter_Drop_TM.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_Drop_TM_lock(_ProjectionRead_Drop_TM_mutex); - _OpCache_Drop_TM.insert({param, _OpCache_with_parameter_Drop_TM}); - } + for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL& param : _trid_20) { + obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_1 = param; - } else { - std::unordered_map<obsw_M001_1::_ProjectionRead_Drop_TM, obsw_M001_1::_ProjectionWrite_Drop_TM, obsw_M001_1::_ProjectionRead_Drop_TM::Hash, obsw_M001_1::_ProjectionRead_Drop_TM::HashEqual> _OpCache_with_parameter_Drop_TM = _OpCache_with_parameter_Drop_TM_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_Drop_TM.find(readState); - if(writeState_ptr != _OpCache_with_parameter_Drop_TM.end()) { - obsw_M001_1::_ProjectionWrite_Drop_TM writeState = writeState_ptr->second; - copiedState._apply_update_for_Drop_TM(writeState); - } else { - copiedState.Drop_TM(_tmp_1); - obsw_M001_1::_ProjectionWrite_Drop_TM writeState = copiedState._update_for_Drop_TM(); - { - std::unique_lock<std::mutex> _ProjectionRead_Drop_TM_lock(_ProjectionRead_Drop_TM_mutex); - _OpCache_with_parameter_Drop_TM.insert({readState, writeState}); - } - } + obsw_M001_1 copiedState = state._copy(); + obsw_M001_1::_ProjectionRead_Drop_TM readState = state._projected_state_for_Drop_TM(); + + auto _OpCache_with_parameter_Drop_TM_ptr = _OpCache_Drop_TM.find(param); + if(_OpCache_with_parameter_Drop_TM_ptr == _OpCache_Drop_TM.end()) { + copiedState.Drop_TM(_tmp_1); + obsw_M001_1::_ProjectionWrite_Drop_TM writeState = copiedState._update_for_Drop_TM(); + std::unordered_map<obsw_M001_1::_ProjectionRead_Drop_TM, obsw_M001_1::_ProjectionWrite_Drop_TM, obsw_M001_1::_ProjectionRead_Drop_TM::Hash, obsw_M001_1::_ProjectionRead_Drop_TM::HashEqual> _OpCache_with_parameter_Drop_TM; + _OpCache_with_parameter_Drop_TM.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_Drop_TM_lock(_ProjectionRead_Drop_TM_mutex); + _OpCache_Drop_TM.insert({param, _OpCache_with_parameter_Drop_TM}); } - copiedState.stateAccessedVia = "Drop_TM"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL> _trid_20 = _trid_20_ptr->second; - for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL& param : _trid_20) { - obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_1 = param; - - obsw_M001_1 copiedState = state._copy(); - obsw_M001_1::_ProjectionRead_Drop_TM readState = state._projected_state_for_Drop_TM(); - - auto _OpCache_with_parameter_Drop_TM_ptr = _OpCache_Drop_TM.find(param); - if(_OpCache_with_parameter_Drop_TM_ptr == _OpCache_Drop_TM.end()) { + } else { + std::unordered_map<obsw_M001_1::_ProjectionRead_Drop_TM, obsw_M001_1::_ProjectionWrite_Drop_TM, obsw_M001_1::_ProjectionRead_Drop_TM::Hash, obsw_M001_1::_ProjectionRead_Drop_TM::HashEqual> _OpCache_with_parameter_Drop_TM = _OpCache_with_parameter_Drop_TM_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_Drop_TM.find(readState); + if(writeState_ptr != _OpCache_with_parameter_Drop_TM.end()) { + obsw_M001_1::_ProjectionWrite_Drop_TM writeState = writeState_ptr->second; + copiedState._apply_update_for_Drop_TM(writeState); + } else { copiedState.Drop_TM(_tmp_1); obsw_M001_1::_ProjectionWrite_Drop_TM writeState = copiedState._update_for_Drop_TM(); - std::unordered_map<obsw_M001_1::_ProjectionRead_Drop_TM, obsw_M001_1::_ProjectionWrite_Drop_TM, obsw_M001_1::_ProjectionRead_Drop_TM::Hash, obsw_M001_1::_ProjectionRead_Drop_TM::HashEqual> _OpCache_with_parameter_Drop_TM; - _OpCache_with_parameter_Drop_TM.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_Drop_TM_lock(_ProjectionRead_Drop_TM_mutex); - _OpCache_Drop_TM.insert({param, _OpCache_with_parameter_Drop_TM}); - } - - } else { - std::unordered_map<obsw_M001_1::_ProjectionRead_Drop_TM, obsw_M001_1::_ProjectionWrite_Drop_TM, obsw_M001_1::_ProjectionRead_Drop_TM::Hash, obsw_M001_1::_ProjectionRead_Drop_TM::HashEqual> _OpCache_with_parameter_Drop_TM = _OpCache_with_parameter_Drop_TM_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_Drop_TM.find(readState); - if(writeState_ptr != _OpCache_with_parameter_Drop_TM.end()) { - obsw_M001_1::_ProjectionWrite_Drop_TM writeState = writeState_ptr->second; - copiedState._apply_update_for_Drop_TM(writeState); - } else { - copiedState.Drop_TM(_tmp_1); - obsw_M001_1::_ProjectionWrite_Drop_TM writeState = copiedState._update_for_Drop_TM(); - { - std::unique_lock<std::mutex> _ProjectionRead_Drop_TM_lock(_ProjectionRead_Drop_TM_mutex); - _OpCache_with_parameter_Drop_TM.insert({readState, writeState}); - } + _OpCache_with_parameter_Drop_TM.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "Drop_TM"; - result.insert(copiedState); + copiedState.stateAccessedVia = "Drop_TM"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } obsw_M001_1::_ProjectionRead__tr_env_Deliver_TM read__tr_env_Deliver_TM_state = state._projected_state_for__tr_env_Deliver_TM(); + BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_BUFFER> _trid_21; auto _trid_21_ptr = _OpCache_tr_env_Deliver_TM.find(read__tr_env_Deliver_TM_state); if(_trid_21_ptr == _OpCache_tr_env_Deliver_TM.end()) { - BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_BUFFER> _trid_21 = state._tr_env_Deliver_TM(); + _trid_21 = state._tr_env_Deliver_TM(); { std::unique_lock<std::mutex> _ProjectionRead__tr_env_Deliver_TM_lock(_ProjectionRead__tr_env_Deliver_TM_mutex); _OpCache_tr_env_Deliver_TM.insert({read__tr_env_Deliver_TM_state, _trid_21}); } - for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_BUFFER& param : _trid_21) { - obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_BUFFER _tmp_1 = param; - - obsw_M001_1 copiedState = state._copy(); - obsw_M001_1::_ProjectionRead_env_Deliver_TM readState = state._projected_state_for_env_Deliver_TM(); + } else { + _trid_21 = _trid_21_ptr->second; + } - auto _OpCache_with_parameter_env_Deliver_TM_ptr = _OpCache_env_Deliver_TM.find(param); - if(_OpCache_with_parameter_env_Deliver_TM_ptr == _OpCache_env_Deliver_TM.end()) { - copiedState.env_Deliver_TM(_tmp_1); - obsw_M001_1::_ProjectionWrite_env_Deliver_TM writeState = copiedState._update_for_env_Deliver_TM(); - std::unordered_map<obsw_M001_1::_ProjectionRead_env_Deliver_TM, obsw_M001_1::_ProjectionWrite_env_Deliver_TM, obsw_M001_1::_ProjectionRead_env_Deliver_TM::Hash, obsw_M001_1::_ProjectionRead_env_Deliver_TM::HashEqual> _OpCache_with_parameter_env_Deliver_TM; - _OpCache_with_parameter_env_Deliver_TM.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_env_Deliver_TM_lock(_ProjectionRead_env_Deliver_TM_mutex); - _OpCache_env_Deliver_TM.insert({param, _OpCache_with_parameter_env_Deliver_TM}); - } + for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_BUFFER& param : _trid_21) { + obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_BUFFER _tmp_1 = param; - } else { - std::unordered_map<obsw_M001_1::_ProjectionRead_env_Deliver_TM, obsw_M001_1::_ProjectionWrite_env_Deliver_TM, obsw_M001_1::_ProjectionRead_env_Deliver_TM::Hash, obsw_M001_1::_ProjectionRead_env_Deliver_TM::HashEqual> _OpCache_with_parameter_env_Deliver_TM = _OpCache_with_parameter_env_Deliver_TM_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_env_Deliver_TM.find(readState); - if(writeState_ptr != _OpCache_with_parameter_env_Deliver_TM.end()) { - obsw_M001_1::_ProjectionWrite_env_Deliver_TM writeState = writeState_ptr->second; - copiedState._apply_update_for_env_Deliver_TM(writeState); - } else { - copiedState.env_Deliver_TM(_tmp_1); - obsw_M001_1::_ProjectionWrite_env_Deliver_TM writeState = copiedState._update_for_env_Deliver_TM(); - { - std::unique_lock<std::mutex> _ProjectionRead_env_Deliver_TM_lock(_ProjectionRead_env_Deliver_TM_mutex); - _OpCache_with_parameter_env_Deliver_TM.insert({readState, writeState}); - } - } + obsw_M001_1 copiedState = state._copy(); + obsw_M001_1::_ProjectionRead_env_Deliver_TM readState = state._projected_state_for_env_Deliver_TM(); + + auto _OpCache_with_parameter_env_Deliver_TM_ptr = _OpCache_env_Deliver_TM.find(param); + if(_OpCache_with_parameter_env_Deliver_TM_ptr == _OpCache_env_Deliver_TM.end()) { + copiedState.env_Deliver_TM(_tmp_1); + obsw_M001_1::_ProjectionWrite_env_Deliver_TM writeState = copiedState._update_for_env_Deliver_TM(); + std::unordered_map<obsw_M001_1::_ProjectionRead_env_Deliver_TM, obsw_M001_1::_ProjectionWrite_env_Deliver_TM, obsw_M001_1::_ProjectionRead_env_Deliver_TM::Hash, obsw_M001_1::_ProjectionRead_env_Deliver_TM::HashEqual> _OpCache_with_parameter_env_Deliver_TM; + _OpCache_with_parameter_env_Deliver_TM.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_env_Deliver_TM_lock(_ProjectionRead_env_Deliver_TM_mutex); + _OpCache_env_Deliver_TM.insert({param, _OpCache_with_parameter_env_Deliver_TM}); } - copiedState.stateAccessedVia = "env_Deliver_TM"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_BUFFER> _trid_21 = _trid_21_ptr->second; - for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_BUFFER& param : _trid_21) { - obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_BUFFER _tmp_1 = param; - - obsw_M001_1 copiedState = state._copy(); - obsw_M001_1::_ProjectionRead_env_Deliver_TM readState = state._projected_state_for_env_Deliver_TM(); - - auto _OpCache_with_parameter_env_Deliver_TM_ptr = _OpCache_env_Deliver_TM.find(param); - if(_OpCache_with_parameter_env_Deliver_TM_ptr == _OpCache_env_Deliver_TM.end()) { + } else { + std::unordered_map<obsw_M001_1::_ProjectionRead_env_Deliver_TM, obsw_M001_1::_ProjectionWrite_env_Deliver_TM, obsw_M001_1::_ProjectionRead_env_Deliver_TM::Hash, obsw_M001_1::_ProjectionRead_env_Deliver_TM::HashEqual> _OpCache_with_parameter_env_Deliver_TM = _OpCache_with_parameter_env_Deliver_TM_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_env_Deliver_TM.find(readState); + if(writeState_ptr != _OpCache_with_parameter_env_Deliver_TM.end()) { + obsw_M001_1::_ProjectionWrite_env_Deliver_TM writeState = writeState_ptr->second; + copiedState._apply_update_for_env_Deliver_TM(writeState); + } else { copiedState.env_Deliver_TM(_tmp_1); obsw_M001_1::_ProjectionWrite_env_Deliver_TM writeState = copiedState._update_for_env_Deliver_TM(); - std::unordered_map<obsw_M001_1::_ProjectionRead_env_Deliver_TM, obsw_M001_1::_ProjectionWrite_env_Deliver_TM, obsw_M001_1::_ProjectionRead_env_Deliver_TM::Hash, obsw_M001_1::_ProjectionRead_env_Deliver_TM::HashEqual> _OpCache_with_parameter_env_Deliver_TM; - _OpCache_with_parameter_env_Deliver_TM.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_env_Deliver_TM_lock(_ProjectionRead_env_Deliver_TM_mutex); - _OpCache_env_Deliver_TM.insert({param, _OpCache_with_parameter_env_Deliver_TM}); - } - - } else { - std::unordered_map<obsw_M001_1::_ProjectionRead_env_Deliver_TM, obsw_M001_1::_ProjectionWrite_env_Deliver_TM, obsw_M001_1::_ProjectionRead_env_Deliver_TM::Hash, obsw_M001_1::_ProjectionRead_env_Deliver_TM::HashEqual> _OpCache_with_parameter_env_Deliver_TM = _OpCache_with_parameter_env_Deliver_TM_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_env_Deliver_TM.find(readState); - if(writeState_ptr != _OpCache_with_parameter_env_Deliver_TM.end()) { - obsw_M001_1::_ProjectionWrite_env_Deliver_TM writeState = writeState_ptr->second; - copiedState._apply_update_for_env_Deliver_TM(writeState); - } else { - copiedState.env_Deliver_TM(_tmp_1); - obsw_M001_1::_ProjectionWrite_env_Deliver_TM writeState = copiedState._update_for_env_Deliver_TM(); - { - std::unique_lock<std::mutex> _ProjectionRead_env_Deliver_TM_lock(_ProjectionRead_env_Deliver_TM_mutex); - _OpCache_with_parameter_env_Deliver_TM.insert({readState, writeState}); - } + _OpCache_with_parameter_env_Deliver_TM.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "env_Deliver_TM"; - result.insert(copiedState); + copiedState.stateAccessedVia = "env_Deliver_TM"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } @@ -7527,7 +6847,10 @@ class ModelChecker { copiedState.env_Receive_TC(_tmp_2, _tmp_1); copiedState.stateAccessedVia = "env_Receive_TC"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_BUFFER >> _trid_2 = state._tr_Poll_TC(); for(const BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_BUFFER >& param : _trid_2) { @@ -7538,7 +6861,10 @@ class ModelChecker { copiedState.Poll_TC(_tmp_2, _tmp_1); copiedState.stateAccessedVia = "Poll_TC"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_3 = state._tr_Accept_TC(); for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_3) { @@ -7548,7 +6874,10 @@ class ModelChecker { copiedState.Accept_TC(_tmp_1); copiedState.stateAccessedVia = "Accept_TC"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_4 = state._tr_Reject_TC(); for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_4) { @@ -7558,7 +6887,10 @@ class ModelChecker { copiedState.Reject_TC(_tmp_1); copiedState.stateAccessedVia = "Reject_TC"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<BTuple<BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::TM_SET >, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL >> _trid_5 = state._tr_Report_TC_Acceptance(); for(const BTuple<BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::TM_SET >, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL >& param : _trid_5) { @@ -7571,7 +6903,10 @@ class ModelChecker { copiedState.Report_TC_Acceptance(_tmp_4, _tmp_3, _tmp_1); copiedState.stateAccessedVia = "Report_TC_Acceptance"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_6 = state._tr_Skip_TC_Acceptance_Report(); for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_6) { @@ -7581,7 +6916,10 @@ class ModelChecker { copiedState.Skip_TC_Acceptance_Report(_tmp_1); copiedState.stateAccessedVia = "Skip_TC_Acceptance_Report"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<BTuple<BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::TM_SET >, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL >> _trid_7 = state._tr_Report_TC_Rejection(); for(const BTuple<BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::TM_SET >, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL >& param : _trid_7) { @@ -7594,7 +6932,10 @@ class ModelChecker { copiedState.Report_TC_Rejection(_tmp_4, _tmp_3, _tmp_1); copiedState.stateAccessedVia = "Report_TC_Rejection"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_8 = state._tr_Skip_TC_Rejection_Report(); for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_8) { @@ -7604,7 +6945,10 @@ class ModelChecker { copiedState.Skip_TC_Rejection_Report(_tmp_1); copiedState.stateAccessedVia = "Skip_TC_Rejection_Report"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_9 = state._tr_Execute_TC_Successfully(); for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_9) { @@ -7614,7 +6958,10 @@ class ModelChecker { copiedState.Execute_TC_Successfully(_tmp_1); copiedState.stateAccessedVia = "Execute_TC_Successfully"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_10 = state._tr_Reset_TM_Buffer(); for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_10) { @@ -7624,7 +6971,10 @@ class ModelChecker { copiedState.Reset_TM_Buffer(_tmp_1); copiedState.stateAccessedVia = "Reset_TM_Buffer"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_11 = state._tr_Fail_TC_Execution(); for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_11) { @@ -7634,7 +6984,10 @@ class ModelChecker { copiedState.Fail_TC_Execution(_tmp_1); copiedState.stateAccessedVia = "Fail_TC_Execution"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<BTuple<BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::TM_SET >, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL >> _trid_12 = state._tr_Report_TC_Execution_Success(); for(const BTuple<BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::TM_SET >, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL >& param : _trid_12) { @@ -7647,7 +7000,10 @@ class ModelChecker { copiedState.Report_TC_Execution_Success(_tmp_4, _tmp_3, _tmp_1); copiedState.stateAccessedVia = "Report_TC_Execution_Success"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_13 = state._tr_Skip_TC_Success_Report(); for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_13) { @@ -7657,7 +7013,10 @@ class ModelChecker { copiedState.Skip_TC_Success_Report(_tmp_1); copiedState.stateAccessedVia = "Skip_TC_Success_Report"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<BTuple<BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::TM_SET >, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL >> _trid_14 = state._tr_Report_TC_Execution_Failure(); for(const BTuple<BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::TM_SET >, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL >& param : _trid_14) { @@ -7670,7 +7029,10 @@ class ModelChecker { copiedState.Report_TC_Execution_Failure(_tmp_4, _tmp_3, _tmp_1); copiedState.stateAccessedVia = "Report_TC_Execution_Failure"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_15 = state._tr_Skip_TC_Failure_Report(); for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_15) { @@ -7680,7 +7042,10 @@ class ModelChecker { copiedState.Skip_TC_Failure_Report(_tmp_1); copiedState.stateAccessedVia = "Skip_TC_Failure_Report"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_16 = state._tr_Drop_TC(); for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_16) { @@ -7690,7 +7055,10 @@ class ModelChecker { copiedState.Drop_TC(_tmp_1); copiedState.stateAccessedVia = "Drop_TC"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<BTuple<obsw_M001_1::TM_SET, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL >> _trid_17 = state._tr_Produce_TM(); for(const BTuple<obsw_M001_1::TM_SET, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL >& param : _trid_17) { @@ -7701,7 +7069,10 @@ class ModelChecker { copiedState.Produce_TM(_tmp_2, _tmp_1); copiedState.stateAccessedVia = "Produce_TM"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_BUFFER >> _trid_18 = state._tr_Pass_TM(); for(const BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_BUFFER >& param : _trid_18) { @@ -7712,7 +7083,10 @@ class ModelChecker { copiedState.Pass_TM(_tmp_2, _tmp_1); copiedState.stateAccessedVia = "Pass_TM"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL> _trid_19 = state._tr_Cancel_TM(); for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL& param : _trid_19) { @@ -7722,7 +7096,10 @@ class ModelChecker { copiedState.Cancel_TM(_tmp_1); copiedState.stateAccessedVia = "Cancel_TM"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL> _trid_20 = state._tr_Drop_TM(); for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL& param : _trid_20) { @@ -7732,7 +7109,10 @@ class ModelChecker { copiedState.Drop_TM(_tmp_1); copiedState.stateAccessedVia = "Drop_TM"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_BUFFER> _trid_21 = state._tr_env_Deliver_TM(); for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_BUFFER& param : _trid_21) { @@ -7742,7 +7122,10 @@ class ModelChecker { copiedState.env_Deliver_TM(_tmp_1); copiedState.stateAccessedVia = "env_Deliver_TM"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } } diff --git a/benchmarks/model_checking_opreuse/C++/obsw_M001_2.cpp b/benchmarks/model_checking_opreuse/C++/obsw_M001_2.cpp index 35f402cdc2db10c9e3e09438d18ebe49530aa5e8..0af3a1dfadfcb752b6f4611851979181e0a56bfc 100644 --- a/benchmarks/model_checking_opreuse/C++/obsw_M001_2.cpp +++ b/benchmarks/model_checking_opreuse/C++/obsw_M001_2.cpp @@ -10,7 +10,6 @@ #include <atomic> #include <any> #include <mutex> -#include <shared_mutex> #include <future> #include <boost/asio/post.hpp> #include <boost/asio/thread_pool.hpp> @@ -5597,12 +5596,16 @@ class ModelChecker { states.insert(machine); unvisitedStates.push_back(machine); - std::atomic<bool> stopThreads(false); + std::atomic<bool> stopThreads; + stopThreads = false; std::atomic<int> possibleQueueChanges; possibleQueueChanges = 0; - while(!unvisitedStates.empty() && !stopThreads.load()) { - possibleQueueChanges.fetch_add(1); + std::atomic<bool> waitFlag; + waitFlag = true; + + while(!unvisitedStates.empty() && !stopThreads) { + possibleQueueChanges += 1; obsw_M001_2 state = next(); std::packaged_task<void()> task([&, state] { std::unordered_set<obsw_M001_2, obsw_M001_2::Hash, obsw_M001_2::HashEqual> nextStates = generateNextStates(state); @@ -5623,12 +5626,14 @@ class ModelChecker { } } - possibleQueueChanges.fetch_sub(1); { std::unique_lock<std::mutex> lock(mutex); - if (!unvisitedStates.empty() || possibleQueueChanges.load() == 0) { + possibleQueueChanges -= 1; + int running = possibleQueueChanges; + if (!unvisitedStates.empty() || running == 0) { { std::unique_lock<std::mutex> lock(waitMutex); + waitFlag = false; waitCV.notify_one(); } } @@ -5638,24 +5643,27 @@ class ModelChecker { if(invariantViolated(state)) { invariantViolatedBool = true; counterExampleState = state; - stopThreads.store(true); + stopThreads = true; } if(nextStates.empty()) { deadlockDetected = true; counterExampleState = state; - stopThreads.store(true); + stopThreads = true; } }); + waitFlag = true; boost::asio::post(workers, std::move(task)); { std::unique_lock<std::mutex> lock(waitMutex); - waitCV.wait(lock, [&] { - return !unvisitedStates.empty() || possibleQueueChanges == 0; - }); + if(unvisitedStates.empty() && possibleQueueChanges > 0) { + waitCV.wait(lock, [&] { + return waitFlag == false; + }); + } } } workers.join(); @@ -5700,1819 +5708,1131 @@ class ModelChecker { std::unordered_set<obsw_M001_2, obsw_M001_2::Hash, obsw_M001_2::HashEqual> result = std::unordered_set<obsw_M001_2, obsw_M001_2::Hash, obsw_M001_2::HashEqual>(); if(isCaching) { obsw_M001_2::_ProjectionRead__tr_env_Receive_TC read__tr_env_Receive_TC_state = state._projected_state_for__tr_env_Receive_TC(); + BSet<BTuple<obsw_M001_2::TC_SET, obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_BUFFER >> _trid_1; auto _trid_1_ptr = _OpCache_tr_env_Receive_TC.find(read__tr_env_Receive_TC_state); if(_trid_1_ptr == _OpCache_tr_env_Receive_TC.end()) { - BSet<BTuple<obsw_M001_2::TC_SET, obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_BUFFER >> _trid_1 = state._tr_env_Receive_TC(); + _trid_1 = state._tr_env_Receive_TC(); { std::unique_lock<std::mutex> _ProjectionRead__tr_env_Receive_TC_lock(_ProjectionRead__tr_env_Receive_TC_mutex); _OpCache_tr_env_Receive_TC.insert({read__tr_env_Receive_TC_state, _trid_1}); } - for(const BTuple<obsw_M001_2::TC_SET, obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_BUFFER >& param : _trid_1) { - obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_BUFFER _tmp_1 = param.projection2(); - obsw_M001_2::TC_SET _tmp_2 = param.projection1(); - - obsw_M001_2 copiedState = state._copy(); - obsw_M001_2::_ProjectionRead_env_Receive_TC readState = state._projected_state_for_env_Receive_TC(); + } else { + _trid_1 = _trid_1_ptr->second; + } - auto _OpCache_with_parameter_env_Receive_TC_ptr = _OpCache_env_Receive_TC.find(param); - if(_OpCache_with_parameter_env_Receive_TC_ptr == _OpCache_env_Receive_TC.end()) { - copiedState.env_Receive_TC(_tmp_2, _tmp_1); - obsw_M001_2::_ProjectionWrite_env_Receive_TC writeState = copiedState._update_for_env_Receive_TC(); - std::unordered_map<obsw_M001_2::_ProjectionRead_env_Receive_TC, obsw_M001_2::_ProjectionWrite_env_Receive_TC, obsw_M001_2::_ProjectionRead_env_Receive_TC::Hash, obsw_M001_2::_ProjectionRead_env_Receive_TC::HashEqual> _OpCache_with_parameter_env_Receive_TC; - _OpCache_with_parameter_env_Receive_TC.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_env_Receive_TC_lock(_ProjectionRead_env_Receive_TC_mutex); - _OpCache_env_Receive_TC.insert({param, _OpCache_with_parameter_env_Receive_TC}); - } + for(const BTuple<obsw_M001_2::TC_SET, obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_BUFFER >& param : _trid_1) { + obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_BUFFER _tmp_1 = param.projection2(); + obsw_M001_2::TC_SET _tmp_2 = param.projection1(); - } else { - std::unordered_map<obsw_M001_2::_ProjectionRead_env_Receive_TC, obsw_M001_2::_ProjectionWrite_env_Receive_TC, obsw_M001_2::_ProjectionRead_env_Receive_TC::Hash, obsw_M001_2::_ProjectionRead_env_Receive_TC::HashEqual> _OpCache_with_parameter_env_Receive_TC = _OpCache_with_parameter_env_Receive_TC_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_env_Receive_TC.find(readState); - if(writeState_ptr != _OpCache_with_parameter_env_Receive_TC.end()) { - obsw_M001_2::_ProjectionWrite_env_Receive_TC writeState = writeState_ptr->second; - copiedState._apply_update_for_env_Receive_TC(writeState); - } else { - copiedState.env_Receive_TC(_tmp_2, _tmp_1); - obsw_M001_2::_ProjectionWrite_env_Receive_TC writeState = copiedState._update_for_env_Receive_TC(); - { - std::unique_lock<std::mutex> _ProjectionRead_env_Receive_TC_lock(_ProjectionRead_env_Receive_TC_mutex); - _OpCache_with_parameter_env_Receive_TC.insert({readState, writeState}); - } - } + obsw_M001_2 copiedState = state._copy(); + obsw_M001_2::_ProjectionRead_env_Receive_TC readState = state._projected_state_for_env_Receive_TC(); + + auto _OpCache_with_parameter_env_Receive_TC_ptr = _OpCache_env_Receive_TC.find(param); + if(_OpCache_with_parameter_env_Receive_TC_ptr == _OpCache_env_Receive_TC.end()) { + copiedState.env_Receive_TC(_tmp_2, _tmp_1); + obsw_M001_2::_ProjectionWrite_env_Receive_TC writeState = copiedState._update_for_env_Receive_TC(); + std::unordered_map<obsw_M001_2::_ProjectionRead_env_Receive_TC, obsw_M001_2::_ProjectionWrite_env_Receive_TC, obsw_M001_2::_ProjectionRead_env_Receive_TC::Hash, obsw_M001_2::_ProjectionRead_env_Receive_TC::HashEqual> _OpCache_with_parameter_env_Receive_TC; + _OpCache_with_parameter_env_Receive_TC.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_env_Receive_TC_lock(_ProjectionRead_env_Receive_TC_mutex); + _OpCache_env_Receive_TC.insert({param, _OpCache_with_parameter_env_Receive_TC}); } - copiedState.stateAccessedVia = "env_Receive_TC"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<BTuple<obsw_M001_2::TC_SET, obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_BUFFER >> _trid_1 = _trid_1_ptr->second; - for(const BTuple<obsw_M001_2::TC_SET, obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_BUFFER >& param : _trid_1) { - obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_BUFFER _tmp_1 = param.projection2(); - obsw_M001_2::TC_SET _tmp_2 = param.projection1(); - - obsw_M001_2 copiedState = state._copy(); - obsw_M001_2::_ProjectionRead_env_Receive_TC readState = state._projected_state_for_env_Receive_TC(); - - auto _OpCache_with_parameter_env_Receive_TC_ptr = _OpCache_env_Receive_TC.find(param); - if(_OpCache_with_parameter_env_Receive_TC_ptr == _OpCache_env_Receive_TC.end()) { + } else { + std::unordered_map<obsw_M001_2::_ProjectionRead_env_Receive_TC, obsw_M001_2::_ProjectionWrite_env_Receive_TC, obsw_M001_2::_ProjectionRead_env_Receive_TC::Hash, obsw_M001_2::_ProjectionRead_env_Receive_TC::HashEqual> _OpCache_with_parameter_env_Receive_TC = _OpCache_with_parameter_env_Receive_TC_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_env_Receive_TC.find(readState); + if(writeState_ptr != _OpCache_with_parameter_env_Receive_TC.end()) { + obsw_M001_2::_ProjectionWrite_env_Receive_TC writeState = writeState_ptr->second; + copiedState._apply_update_for_env_Receive_TC(writeState); + } else { copiedState.env_Receive_TC(_tmp_2, _tmp_1); obsw_M001_2::_ProjectionWrite_env_Receive_TC writeState = copiedState._update_for_env_Receive_TC(); - std::unordered_map<obsw_M001_2::_ProjectionRead_env_Receive_TC, obsw_M001_2::_ProjectionWrite_env_Receive_TC, obsw_M001_2::_ProjectionRead_env_Receive_TC::Hash, obsw_M001_2::_ProjectionRead_env_Receive_TC::HashEqual> _OpCache_with_parameter_env_Receive_TC; - _OpCache_with_parameter_env_Receive_TC.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_env_Receive_TC_lock(_ProjectionRead_env_Receive_TC_mutex); - _OpCache_env_Receive_TC.insert({param, _OpCache_with_parameter_env_Receive_TC}); - } - - } else { - std::unordered_map<obsw_M001_2::_ProjectionRead_env_Receive_TC, obsw_M001_2::_ProjectionWrite_env_Receive_TC, obsw_M001_2::_ProjectionRead_env_Receive_TC::Hash, obsw_M001_2::_ProjectionRead_env_Receive_TC::HashEqual> _OpCache_with_parameter_env_Receive_TC = _OpCache_with_parameter_env_Receive_TC_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_env_Receive_TC.find(readState); - if(writeState_ptr != _OpCache_with_parameter_env_Receive_TC.end()) { - obsw_M001_2::_ProjectionWrite_env_Receive_TC writeState = writeState_ptr->second; - copiedState._apply_update_for_env_Receive_TC(writeState); - } else { - copiedState.env_Receive_TC(_tmp_2, _tmp_1); - obsw_M001_2::_ProjectionWrite_env_Receive_TC writeState = copiedState._update_for_env_Receive_TC(); - { - std::unique_lock<std::mutex> _ProjectionRead_env_Receive_TC_lock(_ProjectionRead_env_Receive_TC_mutex); - _OpCache_with_parameter_env_Receive_TC.insert({readState, writeState}); - } + _OpCache_with_parameter_env_Receive_TC.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "env_Receive_TC"; - result.insert(copiedState); + copiedState.stateAccessedVia = "env_Receive_TC"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } obsw_M001_2::_ProjectionRead__tr_Poll_TC read__tr_Poll_TC_state = state._projected_state_for__tr_Poll_TC(); + BSet<BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_BUFFER >> _trid_2; auto _trid_2_ptr = _OpCache_tr_Poll_TC.find(read__tr_Poll_TC_state); if(_trid_2_ptr == _OpCache_tr_Poll_TC.end()) { - BSet<BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_BUFFER >> _trid_2 = state._tr_Poll_TC(); + _trid_2 = state._tr_Poll_TC(); { std::unique_lock<std::mutex> _ProjectionRead__tr_Poll_TC_lock(_ProjectionRead__tr_Poll_TC_mutex); _OpCache_tr_Poll_TC.insert({read__tr_Poll_TC_state, _trid_2}); } - for(const BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_BUFFER >& param : _trid_2) { - obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_BUFFER _tmp_1 = param.projection2(); - obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_2 = param.projection1(); - - obsw_M001_2 copiedState = state._copy(); - obsw_M001_2::_ProjectionRead_Poll_TC readState = state._projected_state_for_Poll_TC(); + } else { + _trid_2 = _trid_2_ptr->second; + } - auto _OpCache_with_parameter_Poll_TC_ptr = _OpCache_Poll_TC.find(param); - if(_OpCache_with_parameter_Poll_TC_ptr == _OpCache_Poll_TC.end()) { - copiedState.Poll_TC(_tmp_2, _tmp_1); - obsw_M001_2::_ProjectionWrite_Poll_TC writeState = copiedState._update_for_Poll_TC(); - std::unordered_map<obsw_M001_2::_ProjectionRead_Poll_TC, obsw_M001_2::_ProjectionWrite_Poll_TC, obsw_M001_2::_ProjectionRead_Poll_TC::Hash, obsw_M001_2::_ProjectionRead_Poll_TC::HashEqual> _OpCache_with_parameter_Poll_TC; - _OpCache_with_parameter_Poll_TC.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_Poll_TC_lock(_ProjectionRead_Poll_TC_mutex); - _OpCache_Poll_TC.insert({param, _OpCache_with_parameter_Poll_TC}); - } + for(const BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_BUFFER >& param : _trid_2) { + obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_BUFFER _tmp_1 = param.projection2(); + obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_2 = param.projection1(); - } else { - std::unordered_map<obsw_M001_2::_ProjectionRead_Poll_TC, obsw_M001_2::_ProjectionWrite_Poll_TC, obsw_M001_2::_ProjectionRead_Poll_TC::Hash, obsw_M001_2::_ProjectionRead_Poll_TC::HashEqual> _OpCache_with_parameter_Poll_TC = _OpCache_with_parameter_Poll_TC_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_Poll_TC.find(readState); - if(writeState_ptr != _OpCache_with_parameter_Poll_TC.end()) { - obsw_M001_2::_ProjectionWrite_Poll_TC writeState = writeState_ptr->second; - copiedState._apply_update_for_Poll_TC(writeState); - } else { - copiedState.Poll_TC(_tmp_2, _tmp_1); - obsw_M001_2::_ProjectionWrite_Poll_TC writeState = copiedState._update_for_Poll_TC(); - { - std::unique_lock<std::mutex> _ProjectionRead_Poll_TC_lock(_ProjectionRead_Poll_TC_mutex); - _OpCache_with_parameter_Poll_TC.insert({readState, writeState}); - } - } + obsw_M001_2 copiedState = state._copy(); + obsw_M001_2::_ProjectionRead_Poll_TC readState = state._projected_state_for_Poll_TC(); + + auto _OpCache_with_parameter_Poll_TC_ptr = _OpCache_Poll_TC.find(param); + if(_OpCache_with_parameter_Poll_TC_ptr == _OpCache_Poll_TC.end()) { + copiedState.Poll_TC(_tmp_2, _tmp_1); + obsw_M001_2::_ProjectionWrite_Poll_TC writeState = copiedState._update_for_Poll_TC(); + std::unordered_map<obsw_M001_2::_ProjectionRead_Poll_TC, obsw_M001_2::_ProjectionWrite_Poll_TC, obsw_M001_2::_ProjectionRead_Poll_TC::Hash, obsw_M001_2::_ProjectionRead_Poll_TC::HashEqual> _OpCache_with_parameter_Poll_TC; + _OpCache_with_parameter_Poll_TC.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_Poll_TC_lock(_ProjectionRead_Poll_TC_mutex); + _OpCache_Poll_TC.insert({param, _OpCache_with_parameter_Poll_TC}); } - copiedState.stateAccessedVia = "Poll_TC"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_BUFFER >> _trid_2 = _trid_2_ptr->second; - for(const BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_BUFFER >& param : _trid_2) { - obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_BUFFER _tmp_1 = param.projection2(); - obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_2 = param.projection1(); - - obsw_M001_2 copiedState = state._copy(); - obsw_M001_2::_ProjectionRead_Poll_TC readState = state._projected_state_for_Poll_TC(); - - auto _OpCache_with_parameter_Poll_TC_ptr = _OpCache_Poll_TC.find(param); - if(_OpCache_with_parameter_Poll_TC_ptr == _OpCache_Poll_TC.end()) { + } else { + std::unordered_map<obsw_M001_2::_ProjectionRead_Poll_TC, obsw_M001_2::_ProjectionWrite_Poll_TC, obsw_M001_2::_ProjectionRead_Poll_TC::Hash, obsw_M001_2::_ProjectionRead_Poll_TC::HashEqual> _OpCache_with_parameter_Poll_TC = _OpCache_with_parameter_Poll_TC_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_Poll_TC.find(readState); + if(writeState_ptr != _OpCache_with_parameter_Poll_TC.end()) { + obsw_M001_2::_ProjectionWrite_Poll_TC writeState = writeState_ptr->second; + copiedState._apply_update_for_Poll_TC(writeState); + } else { copiedState.Poll_TC(_tmp_2, _tmp_1); obsw_M001_2::_ProjectionWrite_Poll_TC writeState = copiedState._update_for_Poll_TC(); - std::unordered_map<obsw_M001_2::_ProjectionRead_Poll_TC, obsw_M001_2::_ProjectionWrite_Poll_TC, obsw_M001_2::_ProjectionRead_Poll_TC::Hash, obsw_M001_2::_ProjectionRead_Poll_TC::HashEqual> _OpCache_with_parameter_Poll_TC; - _OpCache_with_parameter_Poll_TC.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_Poll_TC_lock(_ProjectionRead_Poll_TC_mutex); - _OpCache_Poll_TC.insert({param, _OpCache_with_parameter_Poll_TC}); - } - - } else { - std::unordered_map<obsw_M001_2::_ProjectionRead_Poll_TC, obsw_M001_2::_ProjectionWrite_Poll_TC, obsw_M001_2::_ProjectionRead_Poll_TC::Hash, obsw_M001_2::_ProjectionRead_Poll_TC::HashEqual> _OpCache_with_parameter_Poll_TC = _OpCache_with_parameter_Poll_TC_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_Poll_TC.find(readState); - if(writeState_ptr != _OpCache_with_parameter_Poll_TC.end()) { - obsw_M001_2::_ProjectionWrite_Poll_TC writeState = writeState_ptr->second; - copiedState._apply_update_for_Poll_TC(writeState); - } else { - copiedState.Poll_TC(_tmp_2, _tmp_1); - obsw_M001_2::_ProjectionWrite_Poll_TC writeState = copiedState._update_for_Poll_TC(); - { - std::unique_lock<std::mutex> _ProjectionRead_Poll_TC_lock(_ProjectionRead_Poll_TC_mutex); - _OpCache_with_parameter_Poll_TC.insert({readState, writeState}); - } + _OpCache_with_parameter_Poll_TC.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "Poll_TC"; - result.insert(copiedState); + copiedState.stateAccessedVia = "Poll_TC"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } obsw_M001_2::_ProjectionRead__tr_Accept_TC read__tr_Accept_TC_state = state._projected_state_for__tr_Accept_TC(); + BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_3; auto _trid_3_ptr = _OpCache_tr_Accept_TC.find(read__tr_Accept_TC_state); if(_trid_3_ptr == _OpCache_tr_Accept_TC.end()) { - BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_3 = state._tr_Accept_TC(); + _trid_3 = state._tr_Accept_TC(); { std::unique_lock<std::mutex> _ProjectionRead__tr_Accept_TC_lock(_ProjectionRead__tr_Accept_TC_mutex); _OpCache_tr_Accept_TC.insert({read__tr_Accept_TC_state, _trid_3}); } - for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_3) { - obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param; - - obsw_M001_2 copiedState = state._copy(); - obsw_M001_2::_ProjectionRead_Accept_TC readState = state._projected_state_for_Accept_TC(); + } else { + _trid_3 = _trid_3_ptr->second; + } - auto _OpCache_with_parameter_Accept_TC_ptr = _OpCache_Accept_TC.find(param); - if(_OpCache_with_parameter_Accept_TC_ptr == _OpCache_Accept_TC.end()) { - copiedState.Accept_TC(_tmp_1); - obsw_M001_2::_ProjectionWrite_Accept_TC writeState = copiedState._update_for_Accept_TC(); - std::unordered_map<obsw_M001_2::_ProjectionRead_Accept_TC, obsw_M001_2::_ProjectionWrite_Accept_TC, obsw_M001_2::_ProjectionRead_Accept_TC::Hash, obsw_M001_2::_ProjectionRead_Accept_TC::HashEqual> _OpCache_with_parameter_Accept_TC; - _OpCache_with_parameter_Accept_TC.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_Accept_TC_lock(_ProjectionRead_Accept_TC_mutex); - _OpCache_Accept_TC.insert({param, _OpCache_with_parameter_Accept_TC}); - } + for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_3) { + obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param; - } else { - std::unordered_map<obsw_M001_2::_ProjectionRead_Accept_TC, obsw_M001_2::_ProjectionWrite_Accept_TC, obsw_M001_2::_ProjectionRead_Accept_TC::Hash, obsw_M001_2::_ProjectionRead_Accept_TC::HashEqual> _OpCache_with_parameter_Accept_TC = _OpCache_with_parameter_Accept_TC_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_Accept_TC.find(readState); - if(writeState_ptr != _OpCache_with_parameter_Accept_TC.end()) { - obsw_M001_2::_ProjectionWrite_Accept_TC writeState = writeState_ptr->second; - copiedState._apply_update_for_Accept_TC(writeState); - } else { - copiedState.Accept_TC(_tmp_1); - obsw_M001_2::_ProjectionWrite_Accept_TC writeState = copiedState._update_for_Accept_TC(); - { - std::unique_lock<std::mutex> _ProjectionRead_Accept_TC_lock(_ProjectionRead_Accept_TC_mutex); - _OpCache_with_parameter_Accept_TC.insert({readState, writeState}); - } - } + obsw_M001_2 copiedState = state._copy(); + obsw_M001_2::_ProjectionRead_Accept_TC readState = state._projected_state_for_Accept_TC(); + + auto _OpCache_with_parameter_Accept_TC_ptr = _OpCache_Accept_TC.find(param); + if(_OpCache_with_parameter_Accept_TC_ptr == _OpCache_Accept_TC.end()) { + copiedState.Accept_TC(_tmp_1); + obsw_M001_2::_ProjectionWrite_Accept_TC writeState = copiedState._update_for_Accept_TC(); + std::unordered_map<obsw_M001_2::_ProjectionRead_Accept_TC, obsw_M001_2::_ProjectionWrite_Accept_TC, obsw_M001_2::_ProjectionRead_Accept_TC::Hash, obsw_M001_2::_ProjectionRead_Accept_TC::HashEqual> _OpCache_with_parameter_Accept_TC; + _OpCache_with_parameter_Accept_TC.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_Accept_TC_lock(_ProjectionRead_Accept_TC_mutex); + _OpCache_Accept_TC.insert({param, _OpCache_with_parameter_Accept_TC}); } - copiedState.stateAccessedVia = "Accept_TC"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_3 = _trid_3_ptr->second; - for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_3) { - obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param; - - obsw_M001_2 copiedState = state._copy(); - obsw_M001_2::_ProjectionRead_Accept_TC readState = state._projected_state_for_Accept_TC(); - - auto _OpCache_with_parameter_Accept_TC_ptr = _OpCache_Accept_TC.find(param); - if(_OpCache_with_parameter_Accept_TC_ptr == _OpCache_Accept_TC.end()) { + } else { + std::unordered_map<obsw_M001_2::_ProjectionRead_Accept_TC, obsw_M001_2::_ProjectionWrite_Accept_TC, obsw_M001_2::_ProjectionRead_Accept_TC::Hash, obsw_M001_2::_ProjectionRead_Accept_TC::HashEqual> _OpCache_with_parameter_Accept_TC = _OpCache_with_parameter_Accept_TC_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_Accept_TC.find(readState); + if(writeState_ptr != _OpCache_with_parameter_Accept_TC.end()) { + obsw_M001_2::_ProjectionWrite_Accept_TC writeState = writeState_ptr->second; + copiedState._apply_update_for_Accept_TC(writeState); + } else { copiedState.Accept_TC(_tmp_1); obsw_M001_2::_ProjectionWrite_Accept_TC writeState = copiedState._update_for_Accept_TC(); - std::unordered_map<obsw_M001_2::_ProjectionRead_Accept_TC, obsw_M001_2::_ProjectionWrite_Accept_TC, obsw_M001_2::_ProjectionRead_Accept_TC::Hash, obsw_M001_2::_ProjectionRead_Accept_TC::HashEqual> _OpCache_with_parameter_Accept_TC; - _OpCache_with_parameter_Accept_TC.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_Accept_TC_lock(_ProjectionRead_Accept_TC_mutex); - _OpCache_Accept_TC.insert({param, _OpCache_with_parameter_Accept_TC}); - } - - } else { - std::unordered_map<obsw_M001_2::_ProjectionRead_Accept_TC, obsw_M001_2::_ProjectionWrite_Accept_TC, obsw_M001_2::_ProjectionRead_Accept_TC::Hash, obsw_M001_2::_ProjectionRead_Accept_TC::HashEqual> _OpCache_with_parameter_Accept_TC = _OpCache_with_parameter_Accept_TC_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_Accept_TC.find(readState); - if(writeState_ptr != _OpCache_with_parameter_Accept_TC.end()) { - obsw_M001_2::_ProjectionWrite_Accept_TC writeState = writeState_ptr->second; - copiedState._apply_update_for_Accept_TC(writeState); - } else { - copiedState.Accept_TC(_tmp_1); - obsw_M001_2::_ProjectionWrite_Accept_TC writeState = copiedState._update_for_Accept_TC(); - { - std::unique_lock<std::mutex> _ProjectionRead_Accept_TC_lock(_ProjectionRead_Accept_TC_mutex); - _OpCache_with_parameter_Accept_TC.insert({readState, writeState}); - } + _OpCache_with_parameter_Accept_TC.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "Accept_TC"; - result.insert(copiedState); + copiedState.stateAccessedVia = "Accept_TC"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } obsw_M001_2::_ProjectionRead__tr_Reject_TC read__tr_Reject_TC_state = state._projected_state_for__tr_Reject_TC(); + BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_4; auto _trid_4_ptr = _OpCache_tr_Reject_TC.find(read__tr_Reject_TC_state); if(_trid_4_ptr == _OpCache_tr_Reject_TC.end()) { - BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_4 = state._tr_Reject_TC(); + _trid_4 = state._tr_Reject_TC(); { std::unique_lock<std::mutex> _ProjectionRead__tr_Reject_TC_lock(_ProjectionRead__tr_Reject_TC_mutex); _OpCache_tr_Reject_TC.insert({read__tr_Reject_TC_state, _trid_4}); } - for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_4) { - obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param; - - obsw_M001_2 copiedState = state._copy(); - obsw_M001_2::_ProjectionRead_Reject_TC readState = state._projected_state_for_Reject_TC(); + } else { + _trid_4 = _trid_4_ptr->second; + } - auto _OpCache_with_parameter_Reject_TC_ptr = _OpCache_Reject_TC.find(param); - if(_OpCache_with_parameter_Reject_TC_ptr == _OpCache_Reject_TC.end()) { - copiedState.Reject_TC(_tmp_1); - obsw_M001_2::_ProjectionWrite_Reject_TC writeState = copiedState._update_for_Reject_TC(); - std::unordered_map<obsw_M001_2::_ProjectionRead_Reject_TC, obsw_M001_2::_ProjectionWrite_Reject_TC, obsw_M001_2::_ProjectionRead_Reject_TC::Hash, obsw_M001_2::_ProjectionRead_Reject_TC::HashEqual> _OpCache_with_parameter_Reject_TC; - _OpCache_with_parameter_Reject_TC.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_Reject_TC_lock(_ProjectionRead_Reject_TC_mutex); - _OpCache_Reject_TC.insert({param, _OpCache_with_parameter_Reject_TC}); - } + for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_4) { + obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param; - } else { - std::unordered_map<obsw_M001_2::_ProjectionRead_Reject_TC, obsw_M001_2::_ProjectionWrite_Reject_TC, obsw_M001_2::_ProjectionRead_Reject_TC::Hash, obsw_M001_2::_ProjectionRead_Reject_TC::HashEqual> _OpCache_with_parameter_Reject_TC = _OpCache_with_parameter_Reject_TC_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_Reject_TC.find(readState); - if(writeState_ptr != _OpCache_with_parameter_Reject_TC.end()) { - obsw_M001_2::_ProjectionWrite_Reject_TC writeState = writeState_ptr->second; - copiedState._apply_update_for_Reject_TC(writeState); - } else { - copiedState.Reject_TC(_tmp_1); - obsw_M001_2::_ProjectionWrite_Reject_TC writeState = copiedState._update_for_Reject_TC(); - { - std::unique_lock<std::mutex> _ProjectionRead_Reject_TC_lock(_ProjectionRead_Reject_TC_mutex); - _OpCache_with_parameter_Reject_TC.insert({readState, writeState}); - } - } + obsw_M001_2 copiedState = state._copy(); + obsw_M001_2::_ProjectionRead_Reject_TC readState = state._projected_state_for_Reject_TC(); + + auto _OpCache_with_parameter_Reject_TC_ptr = _OpCache_Reject_TC.find(param); + if(_OpCache_with_parameter_Reject_TC_ptr == _OpCache_Reject_TC.end()) { + copiedState.Reject_TC(_tmp_1); + obsw_M001_2::_ProjectionWrite_Reject_TC writeState = copiedState._update_for_Reject_TC(); + std::unordered_map<obsw_M001_2::_ProjectionRead_Reject_TC, obsw_M001_2::_ProjectionWrite_Reject_TC, obsw_M001_2::_ProjectionRead_Reject_TC::Hash, obsw_M001_2::_ProjectionRead_Reject_TC::HashEqual> _OpCache_with_parameter_Reject_TC; + _OpCache_with_parameter_Reject_TC.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_Reject_TC_lock(_ProjectionRead_Reject_TC_mutex); + _OpCache_Reject_TC.insert({param, _OpCache_with_parameter_Reject_TC}); } - copiedState.stateAccessedVia = "Reject_TC"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_4 = _trid_4_ptr->second; - for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_4) { - obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param; - - obsw_M001_2 copiedState = state._copy(); - obsw_M001_2::_ProjectionRead_Reject_TC readState = state._projected_state_for_Reject_TC(); - - auto _OpCache_with_parameter_Reject_TC_ptr = _OpCache_Reject_TC.find(param); - if(_OpCache_with_parameter_Reject_TC_ptr == _OpCache_Reject_TC.end()) { + } else { + std::unordered_map<obsw_M001_2::_ProjectionRead_Reject_TC, obsw_M001_2::_ProjectionWrite_Reject_TC, obsw_M001_2::_ProjectionRead_Reject_TC::Hash, obsw_M001_2::_ProjectionRead_Reject_TC::HashEqual> _OpCache_with_parameter_Reject_TC = _OpCache_with_parameter_Reject_TC_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_Reject_TC.find(readState); + if(writeState_ptr != _OpCache_with_parameter_Reject_TC.end()) { + obsw_M001_2::_ProjectionWrite_Reject_TC writeState = writeState_ptr->second; + copiedState._apply_update_for_Reject_TC(writeState); + } else { copiedState.Reject_TC(_tmp_1); obsw_M001_2::_ProjectionWrite_Reject_TC writeState = copiedState._update_for_Reject_TC(); - std::unordered_map<obsw_M001_2::_ProjectionRead_Reject_TC, obsw_M001_2::_ProjectionWrite_Reject_TC, obsw_M001_2::_ProjectionRead_Reject_TC::Hash, obsw_M001_2::_ProjectionRead_Reject_TC::HashEqual> _OpCache_with_parameter_Reject_TC; - _OpCache_with_parameter_Reject_TC.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_Reject_TC_lock(_ProjectionRead_Reject_TC_mutex); - _OpCache_Reject_TC.insert({param, _OpCache_with_parameter_Reject_TC}); - } - - } else { - std::unordered_map<obsw_M001_2::_ProjectionRead_Reject_TC, obsw_M001_2::_ProjectionWrite_Reject_TC, obsw_M001_2::_ProjectionRead_Reject_TC::Hash, obsw_M001_2::_ProjectionRead_Reject_TC::HashEqual> _OpCache_with_parameter_Reject_TC = _OpCache_with_parameter_Reject_TC_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_Reject_TC.find(readState); - if(writeState_ptr != _OpCache_with_parameter_Reject_TC.end()) { - obsw_M001_2::_ProjectionWrite_Reject_TC writeState = writeState_ptr->second; - copiedState._apply_update_for_Reject_TC(writeState); - } else { - copiedState.Reject_TC(_tmp_1); - obsw_M001_2::_ProjectionWrite_Reject_TC writeState = copiedState._update_for_Reject_TC(); - { - std::unique_lock<std::mutex> _ProjectionRead_Reject_TC_lock(_ProjectionRead_Reject_TC_mutex); - _OpCache_with_parameter_Reject_TC.insert({readState, writeState}); - } + _OpCache_with_parameter_Reject_TC.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "Reject_TC"; - result.insert(copiedState); + copiedState.stateAccessedVia = "Reject_TC"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } obsw_M001_2::_ProjectionRead__tr_Report_TC_Acceptance read__tr_Report_TC_Acceptance_state = state._projected_state_for__tr_Report_TC_Acceptance(); + BSet<BTuple<BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::TM_SET >, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL >> _trid_5; auto _trid_5_ptr = _OpCache_tr_Report_TC_Acceptance.find(read__tr_Report_TC_Acceptance_state); if(_trid_5_ptr == _OpCache_tr_Report_TC_Acceptance.end()) { - BSet<BTuple<BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::TM_SET >, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL >> _trid_5 = state._tr_Report_TC_Acceptance(); + _trid_5 = state._tr_Report_TC_Acceptance(); { std::unique_lock<std::mutex> _ProjectionRead__tr_Report_TC_Acceptance_lock(_ProjectionRead__tr_Report_TC_Acceptance_mutex); _OpCache_tr_Report_TC_Acceptance.insert({read__tr_Report_TC_Acceptance_state, _trid_5}); } - for(const BTuple<BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::TM_SET >, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL >& param : _trid_5) { - obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_1 = param.projection2(); - BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::TM_SET > _tmp_2 = param.projection1(); - obsw_M001_2::TM_SET _tmp_3 = _tmp_2.projection2(); - obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_4 = _tmp_2.projection1(); - - obsw_M001_2 copiedState = state._copy(); - obsw_M001_2::_ProjectionRead_Report_TC_Acceptance readState = state._projected_state_for_Report_TC_Acceptance(); + } else { + _trid_5 = _trid_5_ptr->second; + } - auto _OpCache_with_parameter_Report_TC_Acceptance_ptr = _OpCache_Report_TC_Acceptance.find(param); - if(_OpCache_with_parameter_Report_TC_Acceptance_ptr == _OpCache_Report_TC_Acceptance.end()) { - copiedState.Report_TC_Acceptance(_tmp_4, _tmp_3, _tmp_1); - obsw_M001_2::_ProjectionWrite_Report_TC_Acceptance writeState = copiedState._update_for_Report_TC_Acceptance(); - std::unordered_map<obsw_M001_2::_ProjectionRead_Report_TC_Acceptance, obsw_M001_2::_ProjectionWrite_Report_TC_Acceptance, obsw_M001_2::_ProjectionRead_Report_TC_Acceptance::Hash, obsw_M001_2::_ProjectionRead_Report_TC_Acceptance::HashEqual> _OpCache_with_parameter_Report_TC_Acceptance; - _OpCache_with_parameter_Report_TC_Acceptance.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_Report_TC_Acceptance_lock(_ProjectionRead_Report_TC_Acceptance_mutex); - _OpCache_Report_TC_Acceptance.insert({param, _OpCache_with_parameter_Report_TC_Acceptance}); - } + for(const BTuple<BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::TM_SET >, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL >& param : _trid_5) { + obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_1 = param.projection2(); + BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::TM_SET > _tmp_2 = param.projection1(); + obsw_M001_2::TM_SET _tmp_3 = _tmp_2.projection2(); + obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_4 = _tmp_2.projection1(); - } else { - std::unordered_map<obsw_M001_2::_ProjectionRead_Report_TC_Acceptance, obsw_M001_2::_ProjectionWrite_Report_TC_Acceptance, obsw_M001_2::_ProjectionRead_Report_TC_Acceptance::Hash, obsw_M001_2::_ProjectionRead_Report_TC_Acceptance::HashEqual> _OpCache_with_parameter_Report_TC_Acceptance = _OpCache_with_parameter_Report_TC_Acceptance_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_Report_TC_Acceptance.find(readState); - if(writeState_ptr != _OpCache_with_parameter_Report_TC_Acceptance.end()) { - obsw_M001_2::_ProjectionWrite_Report_TC_Acceptance writeState = writeState_ptr->second; - copiedState._apply_update_for_Report_TC_Acceptance(writeState); - } else { - copiedState.Report_TC_Acceptance(_tmp_4, _tmp_3, _tmp_1); - obsw_M001_2::_ProjectionWrite_Report_TC_Acceptance writeState = copiedState._update_for_Report_TC_Acceptance(); - { - std::unique_lock<std::mutex> _ProjectionRead_Report_TC_Acceptance_lock(_ProjectionRead_Report_TC_Acceptance_mutex); - _OpCache_with_parameter_Report_TC_Acceptance.insert({readState, writeState}); - } - } + obsw_M001_2 copiedState = state._copy(); + obsw_M001_2::_ProjectionRead_Report_TC_Acceptance readState = state._projected_state_for_Report_TC_Acceptance(); + + auto _OpCache_with_parameter_Report_TC_Acceptance_ptr = _OpCache_Report_TC_Acceptance.find(param); + if(_OpCache_with_parameter_Report_TC_Acceptance_ptr == _OpCache_Report_TC_Acceptance.end()) { + copiedState.Report_TC_Acceptance(_tmp_4, _tmp_3, _tmp_1); + obsw_M001_2::_ProjectionWrite_Report_TC_Acceptance writeState = copiedState._update_for_Report_TC_Acceptance(); + std::unordered_map<obsw_M001_2::_ProjectionRead_Report_TC_Acceptance, obsw_M001_2::_ProjectionWrite_Report_TC_Acceptance, obsw_M001_2::_ProjectionRead_Report_TC_Acceptance::Hash, obsw_M001_2::_ProjectionRead_Report_TC_Acceptance::HashEqual> _OpCache_with_parameter_Report_TC_Acceptance; + _OpCache_with_parameter_Report_TC_Acceptance.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_Report_TC_Acceptance_lock(_ProjectionRead_Report_TC_Acceptance_mutex); + _OpCache_Report_TC_Acceptance.insert({param, _OpCache_with_parameter_Report_TC_Acceptance}); } - copiedState.stateAccessedVia = "Report_TC_Acceptance"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<BTuple<BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::TM_SET >, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL >> _trid_5 = _trid_5_ptr->second; - for(const BTuple<BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::TM_SET >, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL >& param : _trid_5) { - obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_1 = param.projection2(); - BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::TM_SET > _tmp_2 = param.projection1(); - obsw_M001_2::TM_SET _tmp_3 = _tmp_2.projection2(); - obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_4 = _tmp_2.projection1(); - - obsw_M001_2 copiedState = state._copy(); - obsw_M001_2::_ProjectionRead_Report_TC_Acceptance readState = state._projected_state_for_Report_TC_Acceptance(); - - auto _OpCache_with_parameter_Report_TC_Acceptance_ptr = _OpCache_Report_TC_Acceptance.find(param); - if(_OpCache_with_parameter_Report_TC_Acceptance_ptr == _OpCache_Report_TC_Acceptance.end()) { + } else { + std::unordered_map<obsw_M001_2::_ProjectionRead_Report_TC_Acceptance, obsw_M001_2::_ProjectionWrite_Report_TC_Acceptance, obsw_M001_2::_ProjectionRead_Report_TC_Acceptance::Hash, obsw_M001_2::_ProjectionRead_Report_TC_Acceptance::HashEqual> _OpCache_with_parameter_Report_TC_Acceptance = _OpCache_with_parameter_Report_TC_Acceptance_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_Report_TC_Acceptance.find(readState); + if(writeState_ptr != _OpCache_with_parameter_Report_TC_Acceptance.end()) { + obsw_M001_2::_ProjectionWrite_Report_TC_Acceptance writeState = writeState_ptr->second; + copiedState._apply_update_for_Report_TC_Acceptance(writeState); + } else { copiedState.Report_TC_Acceptance(_tmp_4, _tmp_3, _tmp_1); obsw_M001_2::_ProjectionWrite_Report_TC_Acceptance writeState = copiedState._update_for_Report_TC_Acceptance(); - std::unordered_map<obsw_M001_2::_ProjectionRead_Report_TC_Acceptance, obsw_M001_2::_ProjectionWrite_Report_TC_Acceptance, obsw_M001_2::_ProjectionRead_Report_TC_Acceptance::Hash, obsw_M001_2::_ProjectionRead_Report_TC_Acceptance::HashEqual> _OpCache_with_parameter_Report_TC_Acceptance; - _OpCache_with_parameter_Report_TC_Acceptance.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_Report_TC_Acceptance_lock(_ProjectionRead_Report_TC_Acceptance_mutex); - _OpCache_Report_TC_Acceptance.insert({param, _OpCache_with_parameter_Report_TC_Acceptance}); - } - - } else { - std::unordered_map<obsw_M001_2::_ProjectionRead_Report_TC_Acceptance, obsw_M001_2::_ProjectionWrite_Report_TC_Acceptance, obsw_M001_2::_ProjectionRead_Report_TC_Acceptance::Hash, obsw_M001_2::_ProjectionRead_Report_TC_Acceptance::HashEqual> _OpCache_with_parameter_Report_TC_Acceptance = _OpCache_with_parameter_Report_TC_Acceptance_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_Report_TC_Acceptance.find(readState); - if(writeState_ptr != _OpCache_with_parameter_Report_TC_Acceptance.end()) { - obsw_M001_2::_ProjectionWrite_Report_TC_Acceptance writeState = writeState_ptr->second; - copiedState._apply_update_for_Report_TC_Acceptance(writeState); - } else { - copiedState.Report_TC_Acceptance(_tmp_4, _tmp_3, _tmp_1); - obsw_M001_2::_ProjectionWrite_Report_TC_Acceptance writeState = copiedState._update_for_Report_TC_Acceptance(); - { - std::unique_lock<std::mutex> _ProjectionRead_Report_TC_Acceptance_lock(_ProjectionRead_Report_TC_Acceptance_mutex); - _OpCache_with_parameter_Report_TC_Acceptance.insert({readState, writeState}); - } + _OpCache_with_parameter_Report_TC_Acceptance.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "Report_TC_Acceptance"; - result.insert(copiedState); + copiedState.stateAccessedVia = "Report_TC_Acceptance"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } obsw_M001_2::_ProjectionRead__tr_Skip_TC_Acceptance_Report read__tr_Skip_TC_Acceptance_Report_state = state._projected_state_for__tr_Skip_TC_Acceptance_Report(); + BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_6; auto _trid_6_ptr = _OpCache_tr_Skip_TC_Acceptance_Report.find(read__tr_Skip_TC_Acceptance_Report_state); if(_trid_6_ptr == _OpCache_tr_Skip_TC_Acceptance_Report.end()) { - BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_6 = state._tr_Skip_TC_Acceptance_Report(); + _trid_6 = state._tr_Skip_TC_Acceptance_Report(); { std::unique_lock<std::mutex> _ProjectionRead__tr_Skip_TC_Acceptance_Report_lock(_ProjectionRead__tr_Skip_TC_Acceptance_Report_mutex); _OpCache_tr_Skip_TC_Acceptance_Report.insert({read__tr_Skip_TC_Acceptance_Report_state, _trid_6}); } - for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_6) { - obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param; - - obsw_M001_2 copiedState = state._copy(); - obsw_M001_2::_ProjectionRead_Skip_TC_Acceptance_Report readState = state._projected_state_for_Skip_TC_Acceptance_Report(); + } else { + _trid_6 = _trid_6_ptr->second; + } - auto _OpCache_with_parameter_Skip_TC_Acceptance_Report_ptr = _OpCache_Skip_TC_Acceptance_Report.find(param); - if(_OpCache_with_parameter_Skip_TC_Acceptance_Report_ptr == _OpCache_Skip_TC_Acceptance_Report.end()) { - copiedState.Skip_TC_Acceptance_Report(_tmp_1); - obsw_M001_2::_ProjectionWrite_Skip_TC_Acceptance_Report writeState = copiedState._update_for_Skip_TC_Acceptance_Report(); - std::unordered_map<obsw_M001_2::_ProjectionRead_Skip_TC_Acceptance_Report, obsw_M001_2::_ProjectionWrite_Skip_TC_Acceptance_Report, obsw_M001_2::_ProjectionRead_Skip_TC_Acceptance_Report::Hash, obsw_M001_2::_ProjectionRead_Skip_TC_Acceptance_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Acceptance_Report; - _OpCache_with_parameter_Skip_TC_Acceptance_Report.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_Skip_TC_Acceptance_Report_lock(_ProjectionRead_Skip_TC_Acceptance_Report_mutex); - _OpCache_Skip_TC_Acceptance_Report.insert({param, _OpCache_with_parameter_Skip_TC_Acceptance_Report}); - } + for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_6) { + obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param; - } else { - std::unordered_map<obsw_M001_2::_ProjectionRead_Skip_TC_Acceptance_Report, obsw_M001_2::_ProjectionWrite_Skip_TC_Acceptance_Report, obsw_M001_2::_ProjectionRead_Skip_TC_Acceptance_Report::Hash, obsw_M001_2::_ProjectionRead_Skip_TC_Acceptance_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Acceptance_Report = _OpCache_with_parameter_Skip_TC_Acceptance_Report_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_Skip_TC_Acceptance_Report.find(readState); - if(writeState_ptr != _OpCache_with_parameter_Skip_TC_Acceptance_Report.end()) { - obsw_M001_2::_ProjectionWrite_Skip_TC_Acceptance_Report writeState = writeState_ptr->second; - copiedState._apply_update_for_Skip_TC_Acceptance_Report(writeState); - } else { - copiedState.Skip_TC_Acceptance_Report(_tmp_1); - obsw_M001_2::_ProjectionWrite_Skip_TC_Acceptance_Report writeState = copiedState._update_for_Skip_TC_Acceptance_Report(); - { - std::unique_lock<std::mutex> _ProjectionRead_Skip_TC_Acceptance_Report_lock(_ProjectionRead_Skip_TC_Acceptance_Report_mutex); - _OpCache_with_parameter_Skip_TC_Acceptance_Report.insert({readState, writeState}); - } - } + obsw_M001_2 copiedState = state._copy(); + obsw_M001_2::_ProjectionRead_Skip_TC_Acceptance_Report readState = state._projected_state_for_Skip_TC_Acceptance_Report(); + + auto _OpCache_with_parameter_Skip_TC_Acceptance_Report_ptr = _OpCache_Skip_TC_Acceptance_Report.find(param); + if(_OpCache_with_parameter_Skip_TC_Acceptance_Report_ptr == _OpCache_Skip_TC_Acceptance_Report.end()) { + copiedState.Skip_TC_Acceptance_Report(_tmp_1); + obsw_M001_2::_ProjectionWrite_Skip_TC_Acceptance_Report writeState = copiedState._update_for_Skip_TC_Acceptance_Report(); + std::unordered_map<obsw_M001_2::_ProjectionRead_Skip_TC_Acceptance_Report, obsw_M001_2::_ProjectionWrite_Skip_TC_Acceptance_Report, obsw_M001_2::_ProjectionRead_Skip_TC_Acceptance_Report::Hash, obsw_M001_2::_ProjectionRead_Skip_TC_Acceptance_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Acceptance_Report; + _OpCache_with_parameter_Skip_TC_Acceptance_Report.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_Skip_TC_Acceptance_Report_lock(_ProjectionRead_Skip_TC_Acceptance_Report_mutex); + _OpCache_Skip_TC_Acceptance_Report.insert({param, _OpCache_with_parameter_Skip_TC_Acceptance_Report}); } - copiedState.stateAccessedVia = "Skip_TC_Acceptance_Report"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_6 = _trid_6_ptr->second; - for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_6) { - obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param; - - obsw_M001_2 copiedState = state._copy(); - obsw_M001_2::_ProjectionRead_Skip_TC_Acceptance_Report readState = state._projected_state_for_Skip_TC_Acceptance_Report(); - - auto _OpCache_with_parameter_Skip_TC_Acceptance_Report_ptr = _OpCache_Skip_TC_Acceptance_Report.find(param); - if(_OpCache_with_parameter_Skip_TC_Acceptance_Report_ptr == _OpCache_Skip_TC_Acceptance_Report.end()) { + } else { + std::unordered_map<obsw_M001_2::_ProjectionRead_Skip_TC_Acceptance_Report, obsw_M001_2::_ProjectionWrite_Skip_TC_Acceptance_Report, obsw_M001_2::_ProjectionRead_Skip_TC_Acceptance_Report::Hash, obsw_M001_2::_ProjectionRead_Skip_TC_Acceptance_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Acceptance_Report = _OpCache_with_parameter_Skip_TC_Acceptance_Report_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_Skip_TC_Acceptance_Report.find(readState); + if(writeState_ptr != _OpCache_with_parameter_Skip_TC_Acceptance_Report.end()) { + obsw_M001_2::_ProjectionWrite_Skip_TC_Acceptance_Report writeState = writeState_ptr->second; + copiedState._apply_update_for_Skip_TC_Acceptance_Report(writeState); + } else { copiedState.Skip_TC_Acceptance_Report(_tmp_1); obsw_M001_2::_ProjectionWrite_Skip_TC_Acceptance_Report writeState = copiedState._update_for_Skip_TC_Acceptance_Report(); - std::unordered_map<obsw_M001_2::_ProjectionRead_Skip_TC_Acceptance_Report, obsw_M001_2::_ProjectionWrite_Skip_TC_Acceptance_Report, obsw_M001_2::_ProjectionRead_Skip_TC_Acceptance_Report::Hash, obsw_M001_2::_ProjectionRead_Skip_TC_Acceptance_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Acceptance_Report; - _OpCache_with_parameter_Skip_TC_Acceptance_Report.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_Skip_TC_Acceptance_Report_lock(_ProjectionRead_Skip_TC_Acceptance_Report_mutex); - _OpCache_Skip_TC_Acceptance_Report.insert({param, _OpCache_with_parameter_Skip_TC_Acceptance_Report}); - } - - } else { - std::unordered_map<obsw_M001_2::_ProjectionRead_Skip_TC_Acceptance_Report, obsw_M001_2::_ProjectionWrite_Skip_TC_Acceptance_Report, obsw_M001_2::_ProjectionRead_Skip_TC_Acceptance_Report::Hash, obsw_M001_2::_ProjectionRead_Skip_TC_Acceptance_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Acceptance_Report = _OpCache_with_parameter_Skip_TC_Acceptance_Report_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_Skip_TC_Acceptance_Report.find(readState); - if(writeState_ptr != _OpCache_with_parameter_Skip_TC_Acceptance_Report.end()) { - obsw_M001_2::_ProjectionWrite_Skip_TC_Acceptance_Report writeState = writeState_ptr->second; - copiedState._apply_update_for_Skip_TC_Acceptance_Report(writeState); - } else { - copiedState.Skip_TC_Acceptance_Report(_tmp_1); - obsw_M001_2::_ProjectionWrite_Skip_TC_Acceptance_Report writeState = copiedState._update_for_Skip_TC_Acceptance_Report(); - { - std::unique_lock<std::mutex> _ProjectionRead_Skip_TC_Acceptance_Report_lock(_ProjectionRead_Skip_TC_Acceptance_Report_mutex); - _OpCache_with_parameter_Skip_TC_Acceptance_Report.insert({readState, writeState}); - } + _OpCache_with_parameter_Skip_TC_Acceptance_Report.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "Skip_TC_Acceptance_Report"; - result.insert(copiedState); + copiedState.stateAccessedVia = "Skip_TC_Acceptance_Report"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } obsw_M001_2::_ProjectionRead__tr_Report_TC_Rejection read__tr_Report_TC_Rejection_state = state._projected_state_for__tr_Report_TC_Rejection(); + BSet<BTuple<BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::TM_SET >, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL >> _trid_7; auto _trid_7_ptr = _OpCache_tr_Report_TC_Rejection.find(read__tr_Report_TC_Rejection_state); if(_trid_7_ptr == _OpCache_tr_Report_TC_Rejection.end()) { - BSet<BTuple<BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::TM_SET >, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL >> _trid_7 = state._tr_Report_TC_Rejection(); + _trid_7 = state._tr_Report_TC_Rejection(); { std::unique_lock<std::mutex> _ProjectionRead__tr_Report_TC_Rejection_lock(_ProjectionRead__tr_Report_TC_Rejection_mutex); _OpCache_tr_Report_TC_Rejection.insert({read__tr_Report_TC_Rejection_state, _trid_7}); } - for(const BTuple<BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::TM_SET >, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL >& param : _trid_7) { - obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_1 = param.projection2(); - BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::TM_SET > _tmp_2 = param.projection1(); - obsw_M001_2::TM_SET _tmp_3 = _tmp_2.projection2(); - obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_4 = _tmp_2.projection1(); - - obsw_M001_2 copiedState = state._copy(); - obsw_M001_2::_ProjectionRead_Report_TC_Rejection readState = state._projected_state_for_Report_TC_Rejection(); + } else { + _trid_7 = _trid_7_ptr->second; + } - auto _OpCache_with_parameter_Report_TC_Rejection_ptr = _OpCache_Report_TC_Rejection.find(param); - if(_OpCache_with_parameter_Report_TC_Rejection_ptr == _OpCache_Report_TC_Rejection.end()) { - copiedState.Report_TC_Rejection(_tmp_4, _tmp_3, _tmp_1); - obsw_M001_2::_ProjectionWrite_Report_TC_Rejection writeState = copiedState._update_for_Report_TC_Rejection(); - std::unordered_map<obsw_M001_2::_ProjectionRead_Report_TC_Rejection, obsw_M001_2::_ProjectionWrite_Report_TC_Rejection, obsw_M001_2::_ProjectionRead_Report_TC_Rejection::Hash, obsw_M001_2::_ProjectionRead_Report_TC_Rejection::HashEqual> _OpCache_with_parameter_Report_TC_Rejection; - _OpCache_with_parameter_Report_TC_Rejection.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_Report_TC_Rejection_lock(_ProjectionRead_Report_TC_Rejection_mutex); - _OpCache_Report_TC_Rejection.insert({param, _OpCache_with_parameter_Report_TC_Rejection}); - } + for(const BTuple<BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::TM_SET >, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL >& param : _trid_7) { + obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_1 = param.projection2(); + BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::TM_SET > _tmp_2 = param.projection1(); + obsw_M001_2::TM_SET _tmp_3 = _tmp_2.projection2(); + obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_4 = _tmp_2.projection1(); - } else { - std::unordered_map<obsw_M001_2::_ProjectionRead_Report_TC_Rejection, obsw_M001_2::_ProjectionWrite_Report_TC_Rejection, obsw_M001_2::_ProjectionRead_Report_TC_Rejection::Hash, obsw_M001_2::_ProjectionRead_Report_TC_Rejection::HashEqual> _OpCache_with_parameter_Report_TC_Rejection = _OpCache_with_parameter_Report_TC_Rejection_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_Report_TC_Rejection.find(readState); - if(writeState_ptr != _OpCache_with_parameter_Report_TC_Rejection.end()) { - obsw_M001_2::_ProjectionWrite_Report_TC_Rejection writeState = writeState_ptr->second; - copiedState._apply_update_for_Report_TC_Rejection(writeState); - } else { - copiedState.Report_TC_Rejection(_tmp_4, _tmp_3, _tmp_1); - obsw_M001_2::_ProjectionWrite_Report_TC_Rejection writeState = copiedState._update_for_Report_TC_Rejection(); - { - std::unique_lock<std::mutex> _ProjectionRead_Report_TC_Rejection_lock(_ProjectionRead_Report_TC_Rejection_mutex); - _OpCache_with_parameter_Report_TC_Rejection.insert({readState, writeState}); - } - } + obsw_M001_2 copiedState = state._copy(); + obsw_M001_2::_ProjectionRead_Report_TC_Rejection readState = state._projected_state_for_Report_TC_Rejection(); + + auto _OpCache_with_parameter_Report_TC_Rejection_ptr = _OpCache_Report_TC_Rejection.find(param); + if(_OpCache_with_parameter_Report_TC_Rejection_ptr == _OpCache_Report_TC_Rejection.end()) { + copiedState.Report_TC_Rejection(_tmp_4, _tmp_3, _tmp_1); + obsw_M001_2::_ProjectionWrite_Report_TC_Rejection writeState = copiedState._update_for_Report_TC_Rejection(); + std::unordered_map<obsw_M001_2::_ProjectionRead_Report_TC_Rejection, obsw_M001_2::_ProjectionWrite_Report_TC_Rejection, obsw_M001_2::_ProjectionRead_Report_TC_Rejection::Hash, obsw_M001_2::_ProjectionRead_Report_TC_Rejection::HashEqual> _OpCache_with_parameter_Report_TC_Rejection; + _OpCache_with_parameter_Report_TC_Rejection.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_Report_TC_Rejection_lock(_ProjectionRead_Report_TC_Rejection_mutex); + _OpCache_Report_TC_Rejection.insert({param, _OpCache_with_parameter_Report_TC_Rejection}); } - copiedState.stateAccessedVia = "Report_TC_Rejection"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<BTuple<BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::TM_SET >, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL >> _trid_7 = _trid_7_ptr->second; - for(const BTuple<BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::TM_SET >, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL >& param : _trid_7) { - obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_1 = param.projection2(); - BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::TM_SET > _tmp_2 = param.projection1(); - obsw_M001_2::TM_SET _tmp_3 = _tmp_2.projection2(); - obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_4 = _tmp_2.projection1(); - - obsw_M001_2 copiedState = state._copy(); - obsw_M001_2::_ProjectionRead_Report_TC_Rejection readState = state._projected_state_for_Report_TC_Rejection(); - - auto _OpCache_with_parameter_Report_TC_Rejection_ptr = _OpCache_Report_TC_Rejection.find(param); - if(_OpCache_with_parameter_Report_TC_Rejection_ptr == _OpCache_Report_TC_Rejection.end()) { + } else { + std::unordered_map<obsw_M001_2::_ProjectionRead_Report_TC_Rejection, obsw_M001_2::_ProjectionWrite_Report_TC_Rejection, obsw_M001_2::_ProjectionRead_Report_TC_Rejection::Hash, obsw_M001_2::_ProjectionRead_Report_TC_Rejection::HashEqual> _OpCache_with_parameter_Report_TC_Rejection = _OpCache_with_parameter_Report_TC_Rejection_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_Report_TC_Rejection.find(readState); + if(writeState_ptr != _OpCache_with_parameter_Report_TC_Rejection.end()) { + obsw_M001_2::_ProjectionWrite_Report_TC_Rejection writeState = writeState_ptr->second; + copiedState._apply_update_for_Report_TC_Rejection(writeState); + } else { copiedState.Report_TC_Rejection(_tmp_4, _tmp_3, _tmp_1); obsw_M001_2::_ProjectionWrite_Report_TC_Rejection writeState = copiedState._update_for_Report_TC_Rejection(); - std::unordered_map<obsw_M001_2::_ProjectionRead_Report_TC_Rejection, obsw_M001_2::_ProjectionWrite_Report_TC_Rejection, obsw_M001_2::_ProjectionRead_Report_TC_Rejection::Hash, obsw_M001_2::_ProjectionRead_Report_TC_Rejection::HashEqual> _OpCache_with_parameter_Report_TC_Rejection; - _OpCache_with_parameter_Report_TC_Rejection.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_Report_TC_Rejection_lock(_ProjectionRead_Report_TC_Rejection_mutex); - _OpCache_Report_TC_Rejection.insert({param, _OpCache_with_parameter_Report_TC_Rejection}); - } - - } else { - std::unordered_map<obsw_M001_2::_ProjectionRead_Report_TC_Rejection, obsw_M001_2::_ProjectionWrite_Report_TC_Rejection, obsw_M001_2::_ProjectionRead_Report_TC_Rejection::Hash, obsw_M001_2::_ProjectionRead_Report_TC_Rejection::HashEqual> _OpCache_with_parameter_Report_TC_Rejection = _OpCache_with_parameter_Report_TC_Rejection_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_Report_TC_Rejection.find(readState); - if(writeState_ptr != _OpCache_with_parameter_Report_TC_Rejection.end()) { - obsw_M001_2::_ProjectionWrite_Report_TC_Rejection writeState = writeState_ptr->second; - copiedState._apply_update_for_Report_TC_Rejection(writeState); - } else { - copiedState.Report_TC_Rejection(_tmp_4, _tmp_3, _tmp_1); - obsw_M001_2::_ProjectionWrite_Report_TC_Rejection writeState = copiedState._update_for_Report_TC_Rejection(); - { - std::unique_lock<std::mutex> _ProjectionRead_Report_TC_Rejection_lock(_ProjectionRead_Report_TC_Rejection_mutex); - _OpCache_with_parameter_Report_TC_Rejection.insert({readState, writeState}); - } + _OpCache_with_parameter_Report_TC_Rejection.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "Report_TC_Rejection"; - result.insert(copiedState); + copiedState.stateAccessedVia = "Report_TC_Rejection"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } obsw_M001_2::_ProjectionRead__tr_Skip_TC_Rejection_Report read__tr_Skip_TC_Rejection_Report_state = state._projected_state_for__tr_Skip_TC_Rejection_Report(); + BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_8; auto _trid_8_ptr = _OpCache_tr_Skip_TC_Rejection_Report.find(read__tr_Skip_TC_Rejection_Report_state); if(_trid_8_ptr == _OpCache_tr_Skip_TC_Rejection_Report.end()) { - BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_8 = state._tr_Skip_TC_Rejection_Report(); + _trid_8 = state._tr_Skip_TC_Rejection_Report(); { std::unique_lock<std::mutex> _ProjectionRead__tr_Skip_TC_Rejection_Report_lock(_ProjectionRead__tr_Skip_TC_Rejection_Report_mutex); _OpCache_tr_Skip_TC_Rejection_Report.insert({read__tr_Skip_TC_Rejection_Report_state, _trid_8}); } - for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_8) { - obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param; - - obsw_M001_2 copiedState = state._copy(); - obsw_M001_2::_ProjectionRead_Skip_TC_Rejection_Report readState = state._projected_state_for_Skip_TC_Rejection_Report(); + } else { + _trid_8 = _trid_8_ptr->second; + } - auto _OpCache_with_parameter_Skip_TC_Rejection_Report_ptr = _OpCache_Skip_TC_Rejection_Report.find(param); - if(_OpCache_with_parameter_Skip_TC_Rejection_Report_ptr == _OpCache_Skip_TC_Rejection_Report.end()) { - copiedState.Skip_TC_Rejection_Report(_tmp_1); - obsw_M001_2::_ProjectionWrite_Skip_TC_Rejection_Report writeState = copiedState._update_for_Skip_TC_Rejection_Report(); - std::unordered_map<obsw_M001_2::_ProjectionRead_Skip_TC_Rejection_Report, obsw_M001_2::_ProjectionWrite_Skip_TC_Rejection_Report, obsw_M001_2::_ProjectionRead_Skip_TC_Rejection_Report::Hash, obsw_M001_2::_ProjectionRead_Skip_TC_Rejection_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Rejection_Report; - _OpCache_with_parameter_Skip_TC_Rejection_Report.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_Skip_TC_Rejection_Report_lock(_ProjectionRead_Skip_TC_Rejection_Report_mutex); - _OpCache_Skip_TC_Rejection_Report.insert({param, _OpCache_with_parameter_Skip_TC_Rejection_Report}); - } + for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_8) { + obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param; - } else { - std::unordered_map<obsw_M001_2::_ProjectionRead_Skip_TC_Rejection_Report, obsw_M001_2::_ProjectionWrite_Skip_TC_Rejection_Report, obsw_M001_2::_ProjectionRead_Skip_TC_Rejection_Report::Hash, obsw_M001_2::_ProjectionRead_Skip_TC_Rejection_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Rejection_Report = _OpCache_with_parameter_Skip_TC_Rejection_Report_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_Skip_TC_Rejection_Report.find(readState); - if(writeState_ptr != _OpCache_with_parameter_Skip_TC_Rejection_Report.end()) { - obsw_M001_2::_ProjectionWrite_Skip_TC_Rejection_Report writeState = writeState_ptr->second; - copiedState._apply_update_for_Skip_TC_Rejection_Report(writeState); - } else { - copiedState.Skip_TC_Rejection_Report(_tmp_1); - obsw_M001_2::_ProjectionWrite_Skip_TC_Rejection_Report writeState = copiedState._update_for_Skip_TC_Rejection_Report(); - { - std::unique_lock<std::mutex> _ProjectionRead_Skip_TC_Rejection_Report_lock(_ProjectionRead_Skip_TC_Rejection_Report_mutex); - _OpCache_with_parameter_Skip_TC_Rejection_Report.insert({readState, writeState}); - } - } + obsw_M001_2 copiedState = state._copy(); + obsw_M001_2::_ProjectionRead_Skip_TC_Rejection_Report readState = state._projected_state_for_Skip_TC_Rejection_Report(); + + auto _OpCache_with_parameter_Skip_TC_Rejection_Report_ptr = _OpCache_Skip_TC_Rejection_Report.find(param); + if(_OpCache_with_parameter_Skip_TC_Rejection_Report_ptr == _OpCache_Skip_TC_Rejection_Report.end()) { + copiedState.Skip_TC_Rejection_Report(_tmp_1); + obsw_M001_2::_ProjectionWrite_Skip_TC_Rejection_Report writeState = copiedState._update_for_Skip_TC_Rejection_Report(); + std::unordered_map<obsw_M001_2::_ProjectionRead_Skip_TC_Rejection_Report, obsw_M001_2::_ProjectionWrite_Skip_TC_Rejection_Report, obsw_M001_2::_ProjectionRead_Skip_TC_Rejection_Report::Hash, obsw_M001_2::_ProjectionRead_Skip_TC_Rejection_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Rejection_Report; + _OpCache_with_parameter_Skip_TC_Rejection_Report.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_Skip_TC_Rejection_Report_lock(_ProjectionRead_Skip_TC_Rejection_Report_mutex); + _OpCache_Skip_TC_Rejection_Report.insert({param, _OpCache_with_parameter_Skip_TC_Rejection_Report}); } - copiedState.stateAccessedVia = "Skip_TC_Rejection_Report"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_8 = _trid_8_ptr->second; - for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_8) { - obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param; - - obsw_M001_2 copiedState = state._copy(); - obsw_M001_2::_ProjectionRead_Skip_TC_Rejection_Report readState = state._projected_state_for_Skip_TC_Rejection_Report(); - - auto _OpCache_with_parameter_Skip_TC_Rejection_Report_ptr = _OpCache_Skip_TC_Rejection_Report.find(param); - if(_OpCache_with_parameter_Skip_TC_Rejection_Report_ptr == _OpCache_Skip_TC_Rejection_Report.end()) { + } else { + std::unordered_map<obsw_M001_2::_ProjectionRead_Skip_TC_Rejection_Report, obsw_M001_2::_ProjectionWrite_Skip_TC_Rejection_Report, obsw_M001_2::_ProjectionRead_Skip_TC_Rejection_Report::Hash, obsw_M001_2::_ProjectionRead_Skip_TC_Rejection_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Rejection_Report = _OpCache_with_parameter_Skip_TC_Rejection_Report_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_Skip_TC_Rejection_Report.find(readState); + if(writeState_ptr != _OpCache_with_parameter_Skip_TC_Rejection_Report.end()) { + obsw_M001_2::_ProjectionWrite_Skip_TC_Rejection_Report writeState = writeState_ptr->second; + copiedState._apply_update_for_Skip_TC_Rejection_Report(writeState); + } else { copiedState.Skip_TC_Rejection_Report(_tmp_1); obsw_M001_2::_ProjectionWrite_Skip_TC_Rejection_Report writeState = copiedState._update_for_Skip_TC_Rejection_Report(); - std::unordered_map<obsw_M001_2::_ProjectionRead_Skip_TC_Rejection_Report, obsw_M001_2::_ProjectionWrite_Skip_TC_Rejection_Report, obsw_M001_2::_ProjectionRead_Skip_TC_Rejection_Report::Hash, obsw_M001_2::_ProjectionRead_Skip_TC_Rejection_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Rejection_Report; - _OpCache_with_parameter_Skip_TC_Rejection_Report.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_Skip_TC_Rejection_Report_lock(_ProjectionRead_Skip_TC_Rejection_Report_mutex); - _OpCache_Skip_TC_Rejection_Report.insert({param, _OpCache_with_parameter_Skip_TC_Rejection_Report}); - } - - } else { - std::unordered_map<obsw_M001_2::_ProjectionRead_Skip_TC_Rejection_Report, obsw_M001_2::_ProjectionWrite_Skip_TC_Rejection_Report, obsw_M001_2::_ProjectionRead_Skip_TC_Rejection_Report::Hash, obsw_M001_2::_ProjectionRead_Skip_TC_Rejection_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Rejection_Report = _OpCache_with_parameter_Skip_TC_Rejection_Report_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_Skip_TC_Rejection_Report.find(readState); - if(writeState_ptr != _OpCache_with_parameter_Skip_TC_Rejection_Report.end()) { - obsw_M001_2::_ProjectionWrite_Skip_TC_Rejection_Report writeState = writeState_ptr->second; - copiedState._apply_update_for_Skip_TC_Rejection_Report(writeState); - } else { - copiedState.Skip_TC_Rejection_Report(_tmp_1); - obsw_M001_2::_ProjectionWrite_Skip_TC_Rejection_Report writeState = copiedState._update_for_Skip_TC_Rejection_Report(); - { - std::unique_lock<std::mutex> _ProjectionRead_Skip_TC_Rejection_Report_lock(_ProjectionRead_Skip_TC_Rejection_Report_mutex); - _OpCache_with_parameter_Skip_TC_Rejection_Report.insert({readState, writeState}); - } + _OpCache_with_parameter_Skip_TC_Rejection_Report.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "Skip_TC_Rejection_Report"; - result.insert(copiedState); + copiedState.stateAccessedVia = "Skip_TC_Rejection_Report"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } obsw_M001_2::_ProjectionRead__tr_Execute_TC_Successfully read__tr_Execute_TC_Successfully_state = state._projected_state_for__tr_Execute_TC_Successfully(); + BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_9; auto _trid_9_ptr = _OpCache_tr_Execute_TC_Successfully.find(read__tr_Execute_TC_Successfully_state); if(_trid_9_ptr == _OpCache_tr_Execute_TC_Successfully.end()) { - BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_9 = state._tr_Execute_TC_Successfully(); + _trid_9 = state._tr_Execute_TC_Successfully(); { std::unique_lock<std::mutex> _ProjectionRead__tr_Execute_TC_Successfully_lock(_ProjectionRead__tr_Execute_TC_Successfully_mutex); _OpCache_tr_Execute_TC_Successfully.insert({read__tr_Execute_TC_Successfully_state, _trid_9}); } - for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_9) { - obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param; - - obsw_M001_2 copiedState = state._copy(); - obsw_M001_2::_ProjectionRead_Execute_TC_Successfully readState = state._projected_state_for_Execute_TC_Successfully(); + } else { + _trid_9 = _trid_9_ptr->second; + } - auto _OpCache_with_parameter_Execute_TC_Successfully_ptr = _OpCache_Execute_TC_Successfully.find(param); - if(_OpCache_with_parameter_Execute_TC_Successfully_ptr == _OpCache_Execute_TC_Successfully.end()) { - copiedState.Execute_TC_Successfully(_tmp_1); - obsw_M001_2::_ProjectionWrite_Execute_TC_Successfully writeState = copiedState._update_for_Execute_TC_Successfully(); - std::unordered_map<obsw_M001_2::_ProjectionRead_Execute_TC_Successfully, obsw_M001_2::_ProjectionWrite_Execute_TC_Successfully, obsw_M001_2::_ProjectionRead_Execute_TC_Successfully::Hash, obsw_M001_2::_ProjectionRead_Execute_TC_Successfully::HashEqual> _OpCache_with_parameter_Execute_TC_Successfully; - _OpCache_with_parameter_Execute_TC_Successfully.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_Execute_TC_Successfully_lock(_ProjectionRead_Execute_TC_Successfully_mutex); - _OpCache_Execute_TC_Successfully.insert({param, _OpCache_with_parameter_Execute_TC_Successfully}); - } + for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_9) { + obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param; - } else { - std::unordered_map<obsw_M001_2::_ProjectionRead_Execute_TC_Successfully, obsw_M001_2::_ProjectionWrite_Execute_TC_Successfully, obsw_M001_2::_ProjectionRead_Execute_TC_Successfully::Hash, obsw_M001_2::_ProjectionRead_Execute_TC_Successfully::HashEqual> _OpCache_with_parameter_Execute_TC_Successfully = _OpCache_with_parameter_Execute_TC_Successfully_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_Execute_TC_Successfully.find(readState); - if(writeState_ptr != _OpCache_with_parameter_Execute_TC_Successfully.end()) { - obsw_M001_2::_ProjectionWrite_Execute_TC_Successfully writeState = writeState_ptr->second; - copiedState._apply_update_for_Execute_TC_Successfully(writeState); - } else { - copiedState.Execute_TC_Successfully(_tmp_1); - obsw_M001_2::_ProjectionWrite_Execute_TC_Successfully writeState = copiedState._update_for_Execute_TC_Successfully(); - { - std::unique_lock<std::mutex> _ProjectionRead_Execute_TC_Successfully_lock(_ProjectionRead_Execute_TC_Successfully_mutex); - _OpCache_with_parameter_Execute_TC_Successfully.insert({readState, writeState}); - } - } + obsw_M001_2 copiedState = state._copy(); + obsw_M001_2::_ProjectionRead_Execute_TC_Successfully readState = state._projected_state_for_Execute_TC_Successfully(); + + auto _OpCache_with_parameter_Execute_TC_Successfully_ptr = _OpCache_Execute_TC_Successfully.find(param); + if(_OpCache_with_parameter_Execute_TC_Successfully_ptr == _OpCache_Execute_TC_Successfully.end()) { + copiedState.Execute_TC_Successfully(_tmp_1); + obsw_M001_2::_ProjectionWrite_Execute_TC_Successfully writeState = copiedState._update_for_Execute_TC_Successfully(); + std::unordered_map<obsw_M001_2::_ProjectionRead_Execute_TC_Successfully, obsw_M001_2::_ProjectionWrite_Execute_TC_Successfully, obsw_M001_2::_ProjectionRead_Execute_TC_Successfully::Hash, obsw_M001_2::_ProjectionRead_Execute_TC_Successfully::HashEqual> _OpCache_with_parameter_Execute_TC_Successfully; + _OpCache_with_parameter_Execute_TC_Successfully.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_Execute_TC_Successfully_lock(_ProjectionRead_Execute_TC_Successfully_mutex); + _OpCache_Execute_TC_Successfully.insert({param, _OpCache_with_parameter_Execute_TC_Successfully}); } - copiedState.stateAccessedVia = "Execute_TC_Successfully"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_9 = _trid_9_ptr->second; - for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_9) { - obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param; - - obsw_M001_2 copiedState = state._copy(); - obsw_M001_2::_ProjectionRead_Execute_TC_Successfully readState = state._projected_state_for_Execute_TC_Successfully(); - - auto _OpCache_with_parameter_Execute_TC_Successfully_ptr = _OpCache_Execute_TC_Successfully.find(param); - if(_OpCache_with_parameter_Execute_TC_Successfully_ptr == _OpCache_Execute_TC_Successfully.end()) { + } else { + std::unordered_map<obsw_M001_2::_ProjectionRead_Execute_TC_Successfully, obsw_M001_2::_ProjectionWrite_Execute_TC_Successfully, obsw_M001_2::_ProjectionRead_Execute_TC_Successfully::Hash, obsw_M001_2::_ProjectionRead_Execute_TC_Successfully::HashEqual> _OpCache_with_parameter_Execute_TC_Successfully = _OpCache_with_parameter_Execute_TC_Successfully_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_Execute_TC_Successfully.find(readState); + if(writeState_ptr != _OpCache_with_parameter_Execute_TC_Successfully.end()) { + obsw_M001_2::_ProjectionWrite_Execute_TC_Successfully writeState = writeState_ptr->second; + copiedState._apply_update_for_Execute_TC_Successfully(writeState); + } else { copiedState.Execute_TC_Successfully(_tmp_1); obsw_M001_2::_ProjectionWrite_Execute_TC_Successfully writeState = copiedState._update_for_Execute_TC_Successfully(); - std::unordered_map<obsw_M001_2::_ProjectionRead_Execute_TC_Successfully, obsw_M001_2::_ProjectionWrite_Execute_TC_Successfully, obsw_M001_2::_ProjectionRead_Execute_TC_Successfully::Hash, obsw_M001_2::_ProjectionRead_Execute_TC_Successfully::HashEqual> _OpCache_with_parameter_Execute_TC_Successfully; - _OpCache_with_parameter_Execute_TC_Successfully.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_Execute_TC_Successfully_lock(_ProjectionRead_Execute_TC_Successfully_mutex); - _OpCache_Execute_TC_Successfully.insert({param, _OpCache_with_parameter_Execute_TC_Successfully}); - } - - } else { - std::unordered_map<obsw_M001_2::_ProjectionRead_Execute_TC_Successfully, obsw_M001_2::_ProjectionWrite_Execute_TC_Successfully, obsw_M001_2::_ProjectionRead_Execute_TC_Successfully::Hash, obsw_M001_2::_ProjectionRead_Execute_TC_Successfully::HashEqual> _OpCache_with_parameter_Execute_TC_Successfully = _OpCache_with_parameter_Execute_TC_Successfully_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_Execute_TC_Successfully.find(readState); - if(writeState_ptr != _OpCache_with_parameter_Execute_TC_Successfully.end()) { - obsw_M001_2::_ProjectionWrite_Execute_TC_Successfully writeState = writeState_ptr->second; - copiedState._apply_update_for_Execute_TC_Successfully(writeState); - } else { - copiedState.Execute_TC_Successfully(_tmp_1); - obsw_M001_2::_ProjectionWrite_Execute_TC_Successfully writeState = copiedState._update_for_Execute_TC_Successfully(); - { - std::unique_lock<std::mutex> _ProjectionRead_Execute_TC_Successfully_lock(_ProjectionRead_Execute_TC_Successfully_mutex); - _OpCache_with_parameter_Execute_TC_Successfully.insert({readState, writeState}); - } + _OpCache_with_parameter_Execute_TC_Successfully.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "Execute_TC_Successfully"; - result.insert(copiedState); + copiedState.stateAccessedVia = "Execute_TC_Successfully"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } obsw_M001_2::_ProjectionRead__tr_Reset_TM_Buffer read__tr_Reset_TM_Buffer_state = state._projected_state_for__tr_Reset_TM_Buffer(); + BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_10; auto _trid_10_ptr = _OpCache_tr_Reset_TM_Buffer.find(read__tr_Reset_TM_Buffer_state); if(_trid_10_ptr == _OpCache_tr_Reset_TM_Buffer.end()) { - BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_10 = state._tr_Reset_TM_Buffer(); + _trid_10 = state._tr_Reset_TM_Buffer(); { std::unique_lock<std::mutex> _ProjectionRead__tr_Reset_TM_Buffer_lock(_ProjectionRead__tr_Reset_TM_Buffer_mutex); _OpCache_tr_Reset_TM_Buffer.insert({read__tr_Reset_TM_Buffer_state, _trid_10}); } - for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_10) { - obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param; - - obsw_M001_2 copiedState = state._copy(); - obsw_M001_2::_ProjectionRead_Reset_TM_Buffer readState = state._projected_state_for_Reset_TM_Buffer(); + } else { + _trid_10 = _trid_10_ptr->second; + } - auto _OpCache_with_parameter_Reset_TM_Buffer_ptr = _OpCache_Reset_TM_Buffer.find(param); - if(_OpCache_with_parameter_Reset_TM_Buffer_ptr == _OpCache_Reset_TM_Buffer.end()) { - copiedState.Reset_TM_Buffer(_tmp_1); - obsw_M001_2::_ProjectionWrite_Reset_TM_Buffer writeState = copiedState._update_for_Reset_TM_Buffer(); - std::unordered_map<obsw_M001_2::_ProjectionRead_Reset_TM_Buffer, obsw_M001_2::_ProjectionWrite_Reset_TM_Buffer, obsw_M001_2::_ProjectionRead_Reset_TM_Buffer::Hash, obsw_M001_2::_ProjectionRead_Reset_TM_Buffer::HashEqual> _OpCache_with_parameter_Reset_TM_Buffer; - _OpCache_with_parameter_Reset_TM_Buffer.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_Reset_TM_Buffer_lock(_ProjectionRead_Reset_TM_Buffer_mutex); - _OpCache_Reset_TM_Buffer.insert({param, _OpCache_with_parameter_Reset_TM_Buffer}); - } + for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_10) { + obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param; - } else { - std::unordered_map<obsw_M001_2::_ProjectionRead_Reset_TM_Buffer, obsw_M001_2::_ProjectionWrite_Reset_TM_Buffer, obsw_M001_2::_ProjectionRead_Reset_TM_Buffer::Hash, obsw_M001_2::_ProjectionRead_Reset_TM_Buffer::HashEqual> _OpCache_with_parameter_Reset_TM_Buffer = _OpCache_with_parameter_Reset_TM_Buffer_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_Reset_TM_Buffer.find(readState); - if(writeState_ptr != _OpCache_with_parameter_Reset_TM_Buffer.end()) { - obsw_M001_2::_ProjectionWrite_Reset_TM_Buffer writeState = writeState_ptr->second; - copiedState._apply_update_for_Reset_TM_Buffer(writeState); - } else { - copiedState.Reset_TM_Buffer(_tmp_1); - obsw_M001_2::_ProjectionWrite_Reset_TM_Buffer writeState = copiedState._update_for_Reset_TM_Buffer(); - { - std::unique_lock<std::mutex> _ProjectionRead_Reset_TM_Buffer_lock(_ProjectionRead_Reset_TM_Buffer_mutex); - _OpCache_with_parameter_Reset_TM_Buffer.insert({readState, writeState}); - } - } + obsw_M001_2 copiedState = state._copy(); + obsw_M001_2::_ProjectionRead_Reset_TM_Buffer readState = state._projected_state_for_Reset_TM_Buffer(); + + auto _OpCache_with_parameter_Reset_TM_Buffer_ptr = _OpCache_Reset_TM_Buffer.find(param); + if(_OpCache_with_parameter_Reset_TM_Buffer_ptr == _OpCache_Reset_TM_Buffer.end()) { + copiedState.Reset_TM_Buffer(_tmp_1); + obsw_M001_2::_ProjectionWrite_Reset_TM_Buffer writeState = copiedState._update_for_Reset_TM_Buffer(); + std::unordered_map<obsw_M001_2::_ProjectionRead_Reset_TM_Buffer, obsw_M001_2::_ProjectionWrite_Reset_TM_Buffer, obsw_M001_2::_ProjectionRead_Reset_TM_Buffer::Hash, obsw_M001_2::_ProjectionRead_Reset_TM_Buffer::HashEqual> _OpCache_with_parameter_Reset_TM_Buffer; + _OpCache_with_parameter_Reset_TM_Buffer.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_Reset_TM_Buffer_lock(_ProjectionRead_Reset_TM_Buffer_mutex); + _OpCache_Reset_TM_Buffer.insert({param, _OpCache_with_parameter_Reset_TM_Buffer}); } - copiedState.stateAccessedVia = "Reset_TM_Buffer"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_10 = _trid_10_ptr->second; - for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_10) { - obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param; - - obsw_M001_2 copiedState = state._copy(); - obsw_M001_2::_ProjectionRead_Reset_TM_Buffer readState = state._projected_state_for_Reset_TM_Buffer(); - - auto _OpCache_with_parameter_Reset_TM_Buffer_ptr = _OpCache_Reset_TM_Buffer.find(param); - if(_OpCache_with_parameter_Reset_TM_Buffer_ptr == _OpCache_Reset_TM_Buffer.end()) { + } else { + std::unordered_map<obsw_M001_2::_ProjectionRead_Reset_TM_Buffer, obsw_M001_2::_ProjectionWrite_Reset_TM_Buffer, obsw_M001_2::_ProjectionRead_Reset_TM_Buffer::Hash, obsw_M001_2::_ProjectionRead_Reset_TM_Buffer::HashEqual> _OpCache_with_parameter_Reset_TM_Buffer = _OpCache_with_parameter_Reset_TM_Buffer_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_Reset_TM_Buffer.find(readState); + if(writeState_ptr != _OpCache_with_parameter_Reset_TM_Buffer.end()) { + obsw_M001_2::_ProjectionWrite_Reset_TM_Buffer writeState = writeState_ptr->second; + copiedState._apply_update_for_Reset_TM_Buffer(writeState); + } else { copiedState.Reset_TM_Buffer(_tmp_1); obsw_M001_2::_ProjectionWrite_Reset_TM_Buffer writeState = copiedState._update_for_Reset_TM_Buffer(); - std::unordered_map<obsw_M001_2::_ProjectionRead_Reset_TM_Buffer, obsw_M001_2::_ProjectionWrite_Reset_TM_Buffer, obsw_M001_2::_ProjectionRead_Reset_TM_Buffer::Hash, obsw_M001_2::_ProjectionRead_Reset_TM_Buffer::HashEqual> _OpCache_with_parameter_Reset_TM_Buffer; - _OpCache_with_parameter_Reset_TM_Buffer.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_Reset_TM_Buffer_lock(_ProjectionRead_Reset_TM_Buffer_mutex); - _OpCache_Reset_TM_Buffer.insert({param, _OpCache_with_parameter_Reset_TM_Buffer}); - } - - } else { - std::unordered_map<obsw_M001_2::_ProjectionRead_Reset_TM_Buffer, obsw_M001_2::_ProjectionWrite_Reset_TM_Buffer, obsw_M001_2::_ProjectionRead_Reset_TM_Buffer::Hash, obsw_M001_2::_ProjectionRead_Reset_TM_Buffer::HashEqual> _OpCache_with_parameter_Reset_TM_Buffer = _OpCache_with_parameter_Reset_TM_Buffer_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_Reset_TM_Buffer.find(readState); - if(writeState_ptr != _OpCache_with_parameter_Reset_TM_Buffer.end()) { - obsw_M001_2::_ProjectionWrite_Reset_TM_Buffer writeState = writeState_ptr->second; - copiedState._apply_update_for_Reset_TM_Buffer(writeState); - } else { - copiedState.Reset_TM_Buffer(_tmp_1); - obsw_M001_2::_ProjectionWrite_Reset_TM_Buffer writeState = copiedState._update_for_Reset_TM_Buffer(); - { - std::unique_lock<std::mutex> _ProjectionRead_Reset_TM_Buffer_lock(_ProjectionRead_Reset_TM_Buffer_mutex); - _OpCache_with_parameter_Reset_TM_Buffer.insert({readState, writeState}); - } + _OpCache_with_parameter_Reset_TM_Buffer.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "Reset_TM_Buffer"; - result.insert(copiedState); + copiedState.stateAccessedVia = "Reset_TM_Buffer"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } obsw_M001_2::_ProjectionRead__tr_Fail_TC_Execution read__tr_Fail_TC_Execution_state = state._projected_state_for__tr_Fail_TC_Execution(); + BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_11; auto _trid_11_ptr = _OpCache_tr_Fail_TC_Execution.find(read__tr_Fail_TC_Execution_state); if(_trid_11_ptr == _OpCache_tr_Fail_TC_Execution.end()) { - BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_11 = state._tr_Fail_TC_Execution(); + _trid_11 = state._tr_Fail_TC_Execution(); { std::unique_lock<std::mutex> _ProjectionRead__tr_Fail_TC_Execution_lock(_ProjectionRead__tr_Fail_TC_Execution_mutex); _OpCache_tr_Fail_TC_Execution.insert({read__tr_Fail_TC_Execution_state, _trid_11}); } - for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_11) { - obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param; - - obsw_M001_2 copiedState = state._copy(); - obsw_M001_2::_ProjectionRead_Fail_TC_Execution readState = state._projected_state_for_Fail_TC_Execution(); + } else { + _trid_11 = _trid_11_ptr->second; + } - auto _OpCache_with_parameter_Fail_TC_Execution_ptr = _OpCache_Fail_TC_Execution.find(param); - if(_OpCache_with_parameter_Fail_TC_Execution_ptr == _OpCache_Fail_TC_Execution.end()) { - copiedState.Fail_TC_Execution(_tmp_1); - obsw_M001_2::_ProjectionWrite_Fail_TC_Execution writeState = copiedState._update_for_Fail_TC_Execution(); - std::unordered_map<obsw_M001_2::_ProjectionRead_Fail_TC_Execution, obsw_M001_2::_ProjectionWrite_Fail_TC_Execution, obsw_M001_2::_ProjectionRead_Fail_TC_Execution::Hash, obsw_M001_2::_ProjectionRead_Fail_TC_Execution::HashEqual> _OpCache_with_parameter_Fail_TC_Execution; - _OpCache_with_parameter_Fail_TC_Execution.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_Fail_TC_Execution_lock(_ProjectionRead_Fail_TC_Execution_mutex); - _OpCache_Fail_TC_Execution.insert({param, _OpCache_with_parameter_Fail_TC_Execution}); - } + for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_11) { + obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param; - } else { - std::unordered_map<obsw_M001_2::_ProjectionRead_Fail_TC_Execution, obsw_M001_2::_ProjectionWrite_Fail_TC_Execution, obsw_M001_2::_ProjectionRead_Fail_TC_Execution::Hash, obsw_M001_2::_ProjectionRead_Fail_TC_Execution::HashEqual> _OpCache_with_parameter_Fail_TC_Execution = _OpCache_with_parameter_Fail_TC_Execution_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_Fail_TC_Execution.find(readState); - if(writeState_ptr != _OpCache_with_parameter_Fail_TC_Execution.end()) { - obsw_M001_2::_ProjectionWrite_Fail_TC_Execution writeState = writeState_ptr->second; - copiedState._apply_update_for_Fail_TC_Execution(writeState); - } else { - copiedState.Fail_TC_Execution(_tmp_1); - obsw_M001_2::_ProjectionWrite_Fail_TC_Execution writeState = copiedState._update_for_Fail_TC_Execution(); - { - std::unique_lock<std::mutex> _ProjectionRead_Fail_TC_Execution_lock(_ProjectionRead_Fail_TC_Execution_mutex); - _OpCache_with_parameter_Fail_TC_Execution.insert({readState, writeState}); - } - } + obsw_M001_2 copiedState = state._copy(); + obsw_M001_2::_ProjectionRead_Fail_TC_Execution readState = state._projected_state_for_Fail_TC_Execution(); + + auto _OpCache_with_parameter_Fail_TC_Execution_ptr = _OpCache_Fail_TC_Execution.find(param); + if(_OpCache_with_parameter_Fail_TC_Execution_ptr == _OpCache_Fail_TC_Execution.end()) { + copiedState.Fail_TC_Execution(_tmp_1); + obsw_M001_2::_ProjectionWrite_Fail_TC_Execution writeState = copiedState._update_for_Fail_TC_Execution(); + std::unordered_map<obsw_M001_2::_ProjectionRead_Fail_TC_Execution, obsw_M001_2::_ProjectionWrite_Fail_TC_Execution, obsw_M001_2::_ProjectionRead_Fail_TC_Execution::Hash, obsw_M001_2::_ProjectionRead_Fail_TC_Execution::HashEqual> _OpCache_with_parameter_Fail_TC_Execution; + _OpCache_with_parameter_Fail_TC_Execution.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_Fail_TC_Execution_lock(_ProjectionRead_Fail_TC_Execution_mutex); + _OpCache_Fail_TC_Execution.insert({param, _OpCache_with_parameter_Fail_TC_Execution}); } - copiedState.stateAccessedVia = "Fail_TC_Execution"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_11 = _trid_11_ptr->second; - for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_11) { - obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param; - - obsw_M001_2 copiedState = state._copy(); - obsw_M001_2::_ProjectionRead_Fail_TC_Execution readState = state._projected_state_for_Fail_TC_Execution(); - - auto _OpCache_with_parameter_Fail_TC_Execution_ptr = _OpCache_Fail_TC_Execution.find(param); - if(_OpCache_with_parameter_Fail_TC_Execution_ptr == _OpCache_Fail_TC_Execution.end()) { + } else { + std::unordered_map<obsw_M001_2::_ProjectionRead_Fail_TC_Execution, obsw_M001_2::_ProjectionWrite_Fail_TC_Execution, obsw_M001_2::_ProjectionRead_Fail_TC_Execution::Hash, obsw_M001_2::_ProjectionRead_Fail_TC_Execution::HashEqual> _OpCache_with_parameter_Fail_TC_Execution = _OpCache_with_parameter_Fail_TC_Execution_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_Fail_TC_Execution.find(readState); + if(writeState_ptr != _OpCache_with_parameter_Fail_TC_Execution.end()) { + obsw_M001_2::_ProjectionWrite_Fail_TC_Execution writeState = writeState_ptr->second; + copiedState._apply_update_for_Fail_TC_Execution(writeState); + } else { copiedState.Fail_TC_Execution(_tmp_1); obsw_M001_2::_ProjectionWrite_Fail_TC_Execution writeState = copiedState._update_for_Fail_TC_Execution(); - std::unordered_map<obsw_M001_2::_ProjectionRead_Fail_TC_Execution, obsw_M001_2::_ProjectionWrite_Fail_TC_Execution, obsw_M001_2::_ProjectionRead_Fail_TC_Execution::Hash, obsw_M001_2::_ProjectionRead_Fail_TC_Execution::HashEqual> _OpCache_with_parameter_Fail_TC_Execution; - _OpCache_with_parameter_Fail_TC_Execution.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_Fail_TC_Execution_lock(_ProjectionRead_Fail_TC_Execution_mutex); - _OpCache_Fail_TC_Execution.insert({param, _OpCache_with_parameter_Fail_TC_Execution}); - } - - } else { - std::unordered_map<obsw_M001_2::_ProjectionRead_Fail_TC_Execution, obsw_M001_2::_ProjectionWrite_Fail_TC_Execution, obsw_M001_2::_ProjectionRead_Fail_TC_Execution::Hash, obsw_M001_2::_ProjectionRead_Fail_TC_Execution::HashEqual> _OpCache_with_parameter_Fail_TC_Execution = _OpCache_with_parameter_Fail_TC_Execution_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_Fail_TC_Execution.find(readState); - if(writeState_ptr != _OpCache_with_parameter_Fail_TC_Execution.end()) { - obsw_M001_2::_ProjectionWrite_Fail_TC_Execution writeState = writeState_ptr->second; - copiedState._apply_update_for_Fail_TC_Execution(writeState); - } else { - copiedState.Fail_TC_Execution(_tmp_1); - obsw_M001_2::_ProjectionWrite_Fail_TC_Execution writeState = copiedState._update_for_Fail_TC_Execution(); - { - std::unique_lock<std::mutex> _ProjectionRead_Fail_TC_Execution_lock(_ProjectionRead_Fail_TC_Execution_mutex); - _OpCache_with_parameter_Fail_TC_Execution.insert({readState, writeState}); - } + _OpCache_with_parameter_Fail_TC_Execution.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "Fail_TC_Execution"; - result.insert(copiedState); + copiedState.stateAccessedVia = "Fail_TC_Execution"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } obsw_M001_2::_ProjectionRead__tr_Report_TC_Execution_Success read__tr_Report_TC_Execution_Success_state = state._projected_state_for__tr_Report_TC_Execution_Success(); + BSet<BTuple<BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::TM_SET >, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL >> _trid_12; auto _trid_12_ptr = _OpCache_tr_Report_TC_Execution_Success.find(read__tr_Report_TC_Execution_Success_state); if(_trid_12_ptr == _OpCache_tr_Report_TC_Execution_Success.end()) { - BSet<BTuple<BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::TM_SET >, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL >> _trid_12 = state._tr_Report_TC_Execution_Success(); + _trid_12 = state._tr_Report_TC_Execution_Success(); { std::unique_lock<std::mutex> _ProjectionRead__tr_Report_TC_Execution_Success_lock(_ProjectionRead__tr_Report_TC_Execution_Success_mutex); _OpCache_tr_Report_TC_Execution_Success.insert({read__tr_Report_TC_Execution_Success_state, _trid_12}); } - for(const BTuple<BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::TM_SET >, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL >& param : _trid_12) { - obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_1 = param.projection2(); - BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::TM_SET > _tmp_2 = param.projection1(); - obsw_M001_2::TM_SET _tmp_3 = _tmp_2.projection2(); - obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_4 = _tmp_2.projection1(); - - obsw_M001_2 copiedState = state._copy(); - obsw_M001_2::_ProjectionRead_Report_TC_Execution_Success readState = state._projected_state_for_Report_TC_Execution_Success(); + } else { + _trid_12 = _trid_12_ptr->second; + } - auto _OpCache_with_parameter_Report_TC_Execution_Success_ptr = _OpCache_Report_TC_Execution_Success.find(param); - if(_OpCache_with_parameter_Report_TC_Execution_Success_ptr == _OpCache_Report_TC_Execution_Success.end()) { - copiedState.Report_TC_Execution_Success(_tmp_4, _tmp_3, _tmp_1); - obsw_M001_2::_ProjectionWrite_Report_TC_Execution_Success writeState = copiedState._update_for_Report_TC_Execution_Success(); - std::unordered_map<obsw_M001_2::_ProjectionRead_Report_TC_Execution_Success, obsw_M001_2::_ProjectionWrite_Report_TC_Execution_Success, obsw_M001_2::_ProjectionRead_Report_TC_Execution_Success::Hash, obsw_M001_2::_ProjectionRead_Report_TC_Execution_Success::HashEqual> _OpCache_with_parameter_Report_TC_Execution_Success; - _OpCache_with_parameter_Report_TC_Execution_Success.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_Report_TC_Execution_Success_lock(_ProjectionRead_Report_TC_Execution_Success_mutex); - _OpCache_Report_TC_Execution_Success.insert({param, _OpCache_with_parameter_Report_TC_Execution_Success}); - } + for(const BTuple<BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::TM_SET >, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL >& param : _trid_12) { + obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_1 = param.projection2(); + BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::TM_SET > _tmp_2 = param.projection1(); + obsw_M001_2::TM_SET _tmp_3 = _tmp_2.projection2(); + obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_4 = _tmp_2.projection1(); - } else { - std::unordered_map<obsw_M001_2::_ProjectionRead_Report_TC_Execution_Success, obsw_M001_2::_ProjectionWrite_Report_TC_Execution_Success, obsw_M001_2::_ProjectionRead_Report_TC_Execution_Success::Hash, obsw_M001_2::_ProjectionRead_Report_TC_Execution_Success::HashEqual> _OpCache_with_parameter_Report_TC_Execution_Success = _OpCache_with_parameter_Report_TC_Execution_Success_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_Report_TC_Execution_Success.find(readState); - if(writeState_ptr != _OpCache_with_parameter_Report_TC_Execution_Success.end()) { - obsw_M001_2::_ProjectionWrite_Report_TC_Execution_Success writeState = writeState_ptr->second; - copiedState._apply_update_for_Report_TC_Execution_Success(writeState); - } else { - copiedState.Report_TC_Execution_Success(_tmp_4, _tmp_3, _tmp_1); - obsw_M001_2::_ProjectionWrite_Report_TC_Execution_Success writeState = copiedState._update_for_Report_TC_Execution_Success(); - { - std::unique_lock<std::mutex> _ProjectionRead_Report_TC_Execution_Success_lock(_ProjectionRead_Report_TC_Execution_Success_mutex); - _OpCache_with_parameter_Report_TC_Execution_Success.insert({readState, writeState}); - } - } + obsw_M001_2 copiedState = state._copy(); + obsw_M001_2::_ProjectionRead_Report_TC_Execution_Success readState = state._projected_state_for_Report_TC_Execution_Success(); + + auto _OpCache_with_parameter_Report_TC_Execution_Success_ptr = _OpCache_Report_TC_Execution_Success.find(param); + if(_OpCache_with_parameter_Report_TC_Execution_Success_ptr == _OpCache_Report_TC_Execution_Success.end()) { + copiedState.Report_TC_Execution_Success(_tmp_4, _tmp_3, _tmp_1); + obsw_M001_2::_ProjectionWrite_Report_TC_Execution_Success writeState = copiedState._update_for_Report_TC_Execution_Success(); + std::unordered_map<obsw_M001_2::_ProjectionRead_Report_TC_Execution_Success, obsw_M001_2::_ProjectionWrite_Report_TC_Execution_Success, obsw_M001_2::_ProjectionRead_Report_TC_Execution_Success::Hash, obsw_M001_2::_ProjectionRead_Report_TC_Execution_Success::HashEqual> _OpCache_with_parameter_Report_TC_Execution_Success; + _OpCache_with_parameter_Report_TC_Execution_Success.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_Report_TC_Execution_Success_lock(_ProjectionRead_Report_TC_Execution_Success_mutex); + _OpCache_Report_TC_Execution_Success.insert({param, _OpCache_with_parameter_Report_TC_Execution_Success}); } - copiedState.stateAccessedVia = "Report_TC_Execution_Success"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<BTuple<BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::TM_SET >, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL >> _trid_12 = _trid_12_ptr->second; - for(const BTuple<BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::TM_SET >, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL >& param : _trid_12) { - obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_1 = param.projection2(); - BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::TM_SET > _tmp_2 = param.projection1(); - obsw_M001_2::TM_SET _tmp_3 = _tmp_2.projection2(); - obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_4 = _tmp_2.projection1(); - - obsw_M001_2 copiedState = state._copy(); - obsw_M001_2::_ProjectionRead_Report_TC_Execution_Success readState = state._projected_state_for_Report_TC_Execution_Success(); - - auto _OpCache_with_parameter_Report_TC_Execution_Success_ptr = _OpCache_Report_TC_Execution_Success.find(param); - if(_OpCache_with_parameter_Report_TC_Execution_Success_ptr == _OpCache_Report_TC_Execution_Success.end()) { + } else { + std::unordered_map<obsw_M001_2::_ProjectionRead_Report_TC_Execution_Success, obsw_M001_2::_ProjectionWrite_Report_TC_Execution_Success, obsw_M001_2::_ProjectionRead_Report_TC_Execution_Success::Hash, obsw_M001_2::_ProjectionRead_Report_TC_Execution_Success::HashEqual> _OpCache_with_parameter_Report_TC_Execution_Success = _OpCache_with_parameter_Report_TC_Execution_Success_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_Report_TC_Execution_Success.find(readState); + if(writeState_ptr != _OpCache_with_parameter_Report_TC_Execution_Success.end()) { + obsw_M001_2::_ProjectionWrite_Report_TC_Execution_Success writeState = writeState_ptr->second; + copiedState._apply_update_for_Report_TC_Execution_Success(writeState); + } else { copiedState.Report_TC_Execution_Success(_tmp_4, _tmp_3, _tmp_1); obsw_M001_2::_ProjectionWrite_Report_TC_Execution_Success writeState = copiedState._update_for_Report_TC_Execution_Success(); - std::unordered_map<obsw_M001_2::_ProjectionRead_Report_TC_Execution_Success, obsw_M001_2::_ProjectionWrite_Report_TC_Execution_Success, obsw_M001_2::_ProjectionRead_Report_TC_Execution_Success::Hash, obsw_M001_2::_ProjectionRead_Report_TC_Execution_Success::HashEqual> _OpCache_with_parameter_Report_TC_Execution_Success; - _OpCache_with_parameter_Report_TC_Execution_Success.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_Report_TC_Execution_Success_lock(_ProjectionRead_Report_TC_Execution_Success_mutex); - _OpCache_Report_TC_Execution_Success.insert({param, _OpCache_with_parameter_Report_TC_Execution_Success}); - } - - } else { - std::unordered_map<obsw_M001_2::_ProjectionRead_Report_TC_Execution_Success, obsw_M001_2::_ProjectionWrite_Report_TC_Execution_Success, obsw_M001_2::_ProjectionRead_Report_TC_Execution_Success::Hash, obsw_M001_2::_ProjectionRead_Report_TC_Execution_Success::HashEqual> _OpCache_with_parameter_Report_TC_Execution_Success = _OpCache_with_parameter_Report_TC_Execution_Success_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_Report_TC_Execution_Success.find(readState); - if(writeState_ptr != _OpCache_with_parameter_Report_TC_Execution_Success.end()) { - obsw_M001_2::_ProjectionWrite_Report_TC_Execution_Success writeState = writeState_ptr->second; - copiedState._apply_update_for_Report_TC_Execution_Success(writeState); - } else { - copiedState.Report_TC_Execution_Success(_tmp_4, _tmp_3, _tmp_1); - obsw_M001_2::_ProjectionWrite_Report_TC_Execution_Success writeState = copiedState._update_for_Report_TC_Execution_Success(); - { - std::unique_lock<std::mutex> _ProjectionRead_Report_TC_Execution_Success_lock(_ProjectionRead_Report_TC_Execution_Success_mutex); - _OpCache_with_parameter_Report_TC_Execution_Success.insert({readState, writeState}); - } + _OpCache_with_parameter_Report_TC_Execution_Success.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "Report_TC_Execution_Success"; - result.insert(copiedState); + copiedState.stateAccessedVia = "Report_TC_Execution_Success"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } obsw_M001_2::_ProjectionRead__tr_Skip_TC_Success_Report read__tr_Skip_TC_Success_Report_state = state._projected_state_for__tr_Skip_TC_Success_Report(); + BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_13; auto _trid_13_ptr = _OpCache_tr_Skip_TC_Success_Report.find(read__tr_Skip_TC_Success_Report_state); if(_trid_13_ptr == _OpCache_tr_Skip_TC_Success_Report.end()) { - BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_13 = state._tr_Skip_TC_Success_Report(); + _trid_13 = state._tr_Skip_TC_Success_Report(); { std::unique_lock<std::mutex> _ProjectionRead__tr_Skip_TC_Success_Report_lock(_ProjectionRead__tr_Skip_TC_Success_Report_mutex); _OpCache_tr_Skip_TC_Success_Report.insert({read__tr_Skip_TC_Success_Report_state, _trid_13}); } - for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_13) { - obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param; - - obsw_M001_2 copiedState = state._copy(); - obsw_M001_2::_ProjectionRead_Skip_TC_Success_Report readState = state._projected_state_for_Skip_TC_Success_Report(); + } else { + _trid_13 = _trid_13_ptr->second; + } - auto _OpCache_with_parameter_Skip_TC_Success_Report_ptr = _OpCache_Skip_TC_Success_Report.find(param); - if(_OpCache_with_parameter_Skip_TC_Success_Report_ptr == _OpCache_Skip_TC_Success_Report.end()) { - copiedState.Skip_TC_Success_Report(_tmp_1); - obsw_M001_2::_ProjectionWrite_Skip_TC_Success_Report writeState = copiedState._update_for_Skip_TC_Success_Report(); - std::unordered_map<obsw_M001_2::_ProjectionRead_Skip_TC_Success_Report, obsw_M001_2::_ProjectionWrite_Skip_TC_Success_Report, obsw_M001_2::_ProjectionRead_Skip_TC_Success_Report::Hash, obsw_M001_2::_ProjectionRead_Skip_TC_Success_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Success_Report; - _OpCache_with_parameter_Skip_TC_Success_Report.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_Skip_TC_Success_Report_lock(_ProjectionRead_Skip_TC_Success_Report_mutex); - _OpCache_Skip_TC_Success_Report.insert({param, _OpCache_with_parameter_Skip_TC_Success_Report}); - } + for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_13) { + obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param; - } else { - std::unordered_map<obsw_M001_2::_ProjectionRead_Skip_TC_Success_Report, obsw_M001_2::_ProjectionWrite_Skip_TC_Success_Report, obsw_M001_2::_ProjectionRead_Skip_TC_Success_Report::Hash, obsw_M001_2::_ProjectionRead_Skip_TC_Success_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Success_Report = _OpCache_with_parameter_Skip_TC_Success_Report_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_Skip_TC_Success_Report.find(readState); - if(writeState_ptr != _OpCache_with_parameter_Skip_TC_Success_Report.end()) { - obsw_M001_2::_ProjectionWrite_Skip_TC_Success_Report writeState = writeState_ptr->second; - copiedState._apply_update_for_Skip_TC_Success_Report(writeState); - } else { - copiedState.Skip_TC_Success_Report(_tmp_1); - obsw_M001_2::_ProjectionWrite_Skip_TC_Success_Report writeState = copiedState._update_for_Skip_TC_Success_Report(); - { - std::unique_lock<std::mutex> _ProjectionRead_Skip_TC_Success_Report_lock(_ProjectionRead_Skip_TC_Success_Report_mutex); - _OpCache_with_parameter_Skip_TC_Success_Report.insert({readState, writeState}); - } - } + obsw_M001_2 copiedState = state._copy(); + obsw_M001_2::_ProjectionRead_Skip_TC_Success_Report readState = state._projected_state_for_Skip_TC_Success_Report(); + + auto _OpCache_with_parameter_Skip_TC_Success_Report_ptr = _OpCache_Skip_TC_Success_Report.find(param); + if(_OpCache_with_parameter_Skip_TC_Success_Report_ptr == _OpCache_Skip_TC_Success_Report.end()) { + copiedState.Skip_TC_Success_Report(_tmp_1); + obsw_M001_2::_ProjectionWrite_Skip_TC_Success_Report writeState = copiedState._update_for_Skip_TC_Success_Report(); + std::unordered_map<obsw_M001_2::_ProjectionRead_Skip_TC_Success_Report, obsw_M001_2::_ProjectionWrite_Skip_TC_Success_Report, obsw_M001_2::_ProjectionRead_Skip_TC_Success_Report::Hash, obsw_M001_2::_ProjectionRead_Skip_TC_Success_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Success_Report; + _OpCache_with_parameter_Skip_TC_Success_Report.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_Skip_TC_Success_Report_lock(_ProjectionRead_Skip_TC_Success_Report_mutex); + _OpCache_Skip_TC_Success_Report.insert({param, _OpCache_with_parameter_Skip_TC_Success_Report}); } - copiedState.stateAccessedVia = "Skip_TC_Success_Report"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_13 = _trid_13_ptr->second; - for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_13) { - obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param; - - obsw_M001_2 copiedState = state._copy(); - obsw_M001_2::_ProjectionRead_Skip_TC_Success_Report readState = state._projected_state_for_Skip_TC_Success_Report(); - - auto _OpCache_with_parameter_Skip_TC_Success_Report_ptr = _OpCache_Skip_TC_Success_Report.find(param); - if(_OpCache_with_parameter_Skip_TC_Success_Report_ptr == _OpCache_Skip_TC_Success_Report.end()) { + } else { + std::unordered_map<obsw_M001_2::_ProjectionRead_Skip_TC_Success_Report, obsw_M001_2::_ProjectionWrite_Skip_TC_Success_Report, obsw_M001_2::_ProjectionRead_Skip_TC_Success_Report::Hash, obsw_M001_2::_ProjectionRead_Skip_TC_Success_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Success_Report = _OpCache_with_parameter_Skip_TC_Success_Report_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_Skip_TC_Success_Report.find(readState); + if(writeState_ptr != _OpCache_with_parameter_Skip_TC_Success_Report.end()) { + obsw_M001_2::_ProjectionWrite_Skip_TC_Success_Report writeState = writeState_ptr->second; + copiedState._apply_update_for_Skip_TC_Success_Report(writeState); + } else { copiedState.Skip_TC_Success_Report(_tmp_1); obsw_M001_2::_ProjectionWrite_Skip_TC_Success_Report writeState = copiedState._update_for_Skip_TC_Success_Report(); - std::unordered_map<obsw_M001_2::_ProjectionRead_Skip_TC_Success_Report, obsw_M001_2::_ProjectionWrite_Skip_TC_Success_Report, obsw_M001_2::_ProjectionRead_Skip_TC_Success_Report::Hash, obsw_M001_2::_ProjectionRead_Skip_TC_Success_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Success_Report; - _OpCache_with_parameter_Skip_TC_Success_Report.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_Skip_TC_Success_Report_lock(_ProjectionRead_Skip_TC_Success_Report_mutex); - _OpCache_Skip_TC_Success_Report.insert({param, _OpCache_with_parameter_Skip_TC_Success_Report}); - } - - } else { - std::unordered_map<obsw_M001_2::_ProjectionRead_Skip_TC_Success_Report, obsw_M001_2::_ProjectionWrite_Skip_TC_Success_Report, obsw_M001_2::_ProjectionRead_Skip_TC_Success_Report::Hash, obsw_M001_2::_ProjectionRead_Skip_TC_Success_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Success_Report = _OpCache_with_parameter_Skip_TC_Success_Report_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_Skip_TC_Success_Report.find(readState); - if(writeState_ptr != _OpCache_with_parameter_Skip_TC_Success_Report.end()) { - obsw_M001_2::_ProjectionWrite_Skip_TC_Success_Report writeState = writeState_ptr->second; - copiedState._apply_update_for_Skip_TC_Success_Report(writeState); - } else { - copiedState.Skip_TC_Success_Report(_tmp_1); - obsw_M001_2::_ProjectionWrite_Skip_TC_Success_Report writeState = copiedState._update_for_Skip_TC_Success_Report(); - { - std::unique_lock<std::mutex> _ProjectionRead_Skip_TC_Success_Report_lock(_ProjectionRead_Skip_TC_Success_Report_mutex); - _OpCache_with_parameter_Skip_TC_Success_Report.insert({readState, writeState}); - } + _OpCache_with_parameter_Skip_TC_Success_Report.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "Skip_TC_Success_Report"; - result.insert(copiedState); + copiedState.stateAccessedVia = "Skip_TC_Success_Report"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } obsw_M001_2::_ProjectionRead__tr_Report_TC_Execution_Failure read__tr_Report_TC_Execution_Failure_state = state._projected_state_for__tr_Report_TC_Execution_Failure(); + BSet<BTuple<BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::TM_SET >, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL >> _trid_14; auto _trid_14_ptr = _OpCache_tr_Report_TC_Execution_Failure.find(read__tr_Report_TC_Execution_Failure_state); if(_trid_14_ptr == _OpCache_tr_Report_TC_Execution_Failure.end()) { - BSet<BTuple<BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::TM_SET >, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL >> _trid_14 = state._tr_Report_TC_Execution_Failure(); + _trid_14 = state._tr_Report_TC_Execution_Failure(); { std::unique_lock<std::mutex> _ProjectionRead__tr_Report_TC_Execution_Failure_lock(_ProjectionRead__tr_Report_TC_Execution_Failure_mutex); _OpCache_tr_Report_TC_Execution_Failure.insert({read__tr_Report_TC_Execution_Failure_state, _trid_14}); } - for(const BTuple<BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::TM_SET >, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL >& param : _trid_14) { - obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_1 = param.projection2(); - BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::TM_SET > _tmp_2 = param.projection1(); - obsw_M001_2::TM_SET _tmp_3 = _tmp_2.projection2(); - obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_4 = _tmp_2.projection1(); - - obsw_M001_2 copiedState = state._copy(); - obsw_M001_2::_ProjectionRead_Report_TC_Execution_Failure readState = state._projected_state_for_Report_TC_Execution_Failure(); + } else { + _trid_14 = _trid_14_ptr->second; + } - auto _OpCache_with_parameter_Report_TC_Execution_Failure_ptr = _OpCache_Report_TC_Execution_Failure.find(param); - if(_OpCache_with_parameter_Report_TC_Execution_Failure_ptr == _OpCache_Report_TC_Execution_Failure.end()) { - copiedState.Report_TC_Execution_Failure(_tmp_4, _tmp_3, _tmp_1); - obsw_M001_2::_ProjectionWrite_Report_TC_Execution_Failure writeState = copiedState._update_for_Report_TC_Execution_Failure(); - std::unordered_map<obsw_M001_2::_ProjectionRead_Report_TC_Execution_Failure, obsw_M001_2::_ProjectionWrite_Report_TC_Execution_Failure, obsw_M001_2::_ProjectionRead_Report_TC_Execution_Failure::Hash, obsw_M001_2::_ProjectionRead_Report_TC_Execution_Failure::HashEqual> _OpCache_with_parameter_Report_TC_Execution_Failure; - _OpCache_with_parameter_Report_TC_Execution_Failure.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_Report_TC_Execution_Failure_lock(_ProjectionRead_Report_TC_Execution_Failure_mutex); - _OpCache_Report_TC_Execution_Failure.insert({param, _OpCache_with_parameter_Report_TC_Execution_Failure}); - } + for(const BTuple<BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::TM_SET >, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL >& param : _trid_14) { + obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_1 = param.projection2(); + BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::TM_SET > _tmp_2 = param.projection1(); + obsw_M001_2::TM_SET _tmp_3 = _tmp_2.projection2(); + obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_4 = _tmp_2.projection1(); - } else { - std::unordered_map<obsw_M001_2::_ProjectionRead_Report_TC_Execution_Failure, obsw_M001_2::_ProjectionWrite_Report_TC_Execution_Failure, obsw_M001_2::_ProjectionRead_Report_TC_Execution_Failure::Hash, obsw_M001_2::_ProjectionRead_Report_TC_Execution_Failure::HashEqual> _OpCache_with_parameter_Report_TC_Execution_Failure = _OpCache_with_parameter_Report_TC_Execution_Failure_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_Report_TC_Execution_Failure.find(readState); - if(writeState_ptr != _OpCache_with_parameter_Report_TC_Execution_Failure.end()) { - obsw_M001_2::_ProjectionWrite_Report_TC_Execution_Failure writeState = writeState_ptr->second; - copiedState._apply_update_for_Report_TC_Execution_Failure(writeState); - } else { - copiedState.Report_TC_Execution_Failure(_tmp_4, _tmp_3, _tmp_1); - obsw_M001_2::_ProjectionWrite_Report_TC_Execution_Failure writeState = copiedState._update_for_Report_TC_Execution_Failure(); - { - std::unique_lock<std::mutex> _ProjectionRead_Report_TC_Execution_Failure_lock(_ProjectionRead_Report_TC_Execution_Failure_mutex); - _OpCache_with_parameter_Report_TC_Execution_Failure.insert({readState, writeState}); - } - } + obsw_M001_2 copiedState = state._copy(); + obsw_M001_2::_ProjectionRead_Report_TC_Execution_Failure readState = state._projected_state_for_Report_TC_Execution_Failure(); + + auto _OpCache_with_parameter_Report_TC_Execution_Failure_ptr = _OpCache_Report_TC_Execution_Failure.find(param); + if(_OpCache_with_parameter_Report_TC_Execution_Failure_ptr == _OpCache_Report_TC_Execution_Failure.end()) { + copiedState.Report_TC_Execution_Failure(_tmp_4, _tmp_3, _tmp_1); + obsw_M001_2::_ProjectionWrite_Report_TC_Execution_Failure writeState = copiedState._update_for_Report_TC_Execution_Failure(); + std::unordered_map<obsw_M001_2::_ProjectionRead_Report_TC_Execution_Failure, obsw_M001_2::_ProjectionWrite_Report_TC_Execution_Failure, obsw_M001_2::_ProjectionRead_Report_TC_Execution_Failure::Hash, obsw_M001_2::_ProjectionRead_Report_TC_Execution_Failure::HashEqual> _OpCache_with_parameter_Report_TC_Execution_Failure; + _OpCache_with_parameter_Report_TC_Execution_Failure.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_Report_TC_Execution_Failure_lock(_ProjectionRead_Report_TC_Execution_Failure_mutex); + _OpCache_Report_TC_Execution_Failure.insert({param, _OpCache_with_parameter_Report_TC_Execution_Failure}); } - copiedState.stateAccessedVia = "Report_TC_Execution_Failure"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<BTuple<BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::TM_SET >, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL >> _trid_14 = _trid_14_ptr->second; - for(const BTuple<BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::TM_SET >, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL >& param : _trid_14) { - obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_1 = param.projection2(); - BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::TM_SET > _tmp_2 = param.projection1(); - obsw_M001_2::TM_SET _tmp_3 = _tmp_2.projection2(); - obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_4 = _tmp_2.projection1(); - - obsw_M001_2 copiedState = state._copy(); - obsw_M001_2::_ProjectionRead_Report_TC_Execution_Failure readState = state._projected_state_for_Report_TC_Execution_Failure(); - - auto _OpCache_with_parameter_Report_TC_Execution_Failure_ptr = _OpCache_Report_TC_Execution_Failure.find(param); - if(_OpCache_with_parameter_Report_TC_Execution_Failure_ptr == _OpCache_Report_TC_Execution_Failure.end()) { + } else { + std::unordered_map<obsw_M001_2::_ProjectionRead_Report_TC_Execution_Failure, obsw_M001_2::_ProjectionWrite_Report_TC_Execution_Failure, obsw_M001_2::_ProjectionRead_Report_TC_Execution_Failure::Hash, obsw_M001_2::_ProjectionRead_Report_TC_Execution_Failure::HashEqual> _OpCache_with_parameter_Report_TC_Execution_Failure = _OpCache_with_parameter_Report_TC_Execution_Failure_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_Report_TC_Execution_Failure.find(readState); + if(writeState_ptr != _OpCache_with_parameter_Report_TC_Execution_Failure.end()) { + obsw_M001_2::_ProjectionWrite_Report_TC_Execution_Failure writeState = writeState_ptr->second; + copiedState._apply_update_for_Report_TC_Execution_Failure(writeState); + } else { copiedState.Report_TC_Execution_Failure(_tmp_4, _tmp_3, _tmp_1); obsw_M001_2::_ProjectionWrite_Report_TC_Execution_Failure writeState = copiedState._update_for_Report_TC_Execution_Failure(); - std::unordered_map<obsw_M001_2::_ProjectionRead_Report_TC_Execution_Failure, obsw_M001_2::_ProjectionWrite_Report_TC_Execution_Failure, obsw_M001_2::_ProjectionRead_Report_TC_Execution_Failure::Hash, obsw_M001_2::_ProjectionRead_Report_TC_Execution_Failure::HashEqual> _OpCache_with_parameter_Report_TC_Execution_Failure; - _OpCache_with_parameter_Report_TC_Execution_Failure.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_Report_TC_Execution_Failure_lock(_ProjectionRead_Report_TC_Execution_Failure_mutex); - _OpCache_Report_TC_Execution_Failure.insert({param, _OpCache_with_parameter_Report_TC_Execution_Failure}); - } - - } else { - std::unordered_map<obsw_M001_2::_ProjectionRead_Report_TC_Execution_Failure, obsw_M001_2::_ProjectionWrite_Report_TC_Execution_Failure, obsw_M001_2::_ProjectionRead_Report_TC_Execution_Failure::Hash, obsw_M001_2::_ProjectionRead_Report_TC_Execution_Failure::HashEqual> _OpCache_with_parameter_Report_TC_Execution_Failure = _OpCache_with_parameter_Report_TC_Execution_Failure_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_Report_TC_Execution_Failure.find(readState); - if(writeState_ptr != _OpCache_with_parameter_Report_TC_Execution_Failure.end()) { - obsw_M001_2::_ProjectionWrite_Report_TC_Execution_Failure writeState = writeState_ptr->second; - copiedState._apply_update_for_Report_TC_Execution_Failure(writeState); - } else { - copiedState.Report_TC_Execution_Failure(_tmp_4, _tmp_3, _tmp_1); - obsw_M001_2::_ProjectionWrite_Report_TC_Execution_Failure writeState = copiedState._update_for_Report_TC_Execution_Failure(); - { - std::unique_lock<std::mutex> _ProjectionRead_Report_TC_Execution_Failure_lock(_ProjectionRead_Report_TC_Execution_Failure_mutex); - _OpCache_with_parameter_Report_TC_Execution_Failure.insert({readState, writeState}); - } + _OpCache_with_parameter_Report_TC_Execution_Failure.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "Report_TC_Execution_Failure"; - result.insert(copiedState); + copiedState.stateAccessedVia = "Report_TC_Execution_Failure"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } obsw_M001_2::_ProjectionRead__tr_Skip_TC_Failure_Report read__tr_Skip_TC_Failure_Report_state = state._projected_state_for__tr_Skip_TC_Failure_Report(); + BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_15; auto _trid_15_ptr = _OpCache_tr_Skip_TC_Failure_Report.find(read__tr_Skip_TC_Failure_Report_state); if(_trid_15_ptr == _OpCache_tr_Skip_TC_Failure_Report.end()) { - BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_15 = state._tr_Skip_TC_Failure_Report(); + _trid_15 = state._tr_Skip_TC_Failure_Report(); { std::unique_lock<std::mutex> _ProjectionRead__tr_Skip_TC_Failure_Report_lock(_ProjectionRead__tr_Skip_TC_Failure_Report_mutex); _OpCache_tr_Skip_TC_Failure_Report.insert({read__tr_Skip_TC_Failure_Report_state, _trid_15}); } - for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_15) { - obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param; - - obsw_M001_2 copiedState = state._copy(); - obsw_M001_2::_ProjectionRead_Skip_TC_Failure_Report readState = state._projected_state_for_Skip_TC_Failure_Report(); + } else { + _trid_15 = _trid_15_ptr->second; + } - auto _OpCache_with_parameter_Skip_TC_Failure_Report_ptr = _OpCache_Skip_TC_Failure_Report.find(param); - if(_OpCache_with_parameter_Skip_TC_Failure_Report_ptr == _OpCache_Skip_TC_Failure_Report.end()) { - copiedState.Skip_TC_Failure_Report(_tmp_1); - obsw_M001_2::_ProjectionWrite_Skip_TC_Failure_Report writeState = copiedState._update_for_Skip_TC_Failure_Report(); - std::unordered_map<obsw_M001_2::_ProjectionRead_Skip_TC_Failure_Report, obsw_M001_2::_ProjectionWrite_Skip_TC_Failure_Report, obsw_M001_2::_ProjectionRead_Skip_TC_Failure_Report::Hash, obsw_M001_2::_ProjectionRead_Skip_TC_Failure_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Failure_Report; - _OpCache_with_parameter_Skip_TC_Failure_Report.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_Skip_TC_Failure_Report_lock(_ProjectionRead_Skip_TC_Failure_Report_mutex); - _OpCache_Skip_TC_Failure_Report.insert({param, _OpCache_with_parameter_Skip_TC_Failure_Report}); - } + for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_15) { + obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param; - } else { - std::unordered_map<obsw_M001_2::_ProjectionRead_Skip_TC_Failure_Report, obsw_M001_2::_ProjectionWrite_Skip_TC_Failure_Report, obsw_M001_2::_ProjectionRead_Skip_TC_Failure_Report::Hash, obsw_M001_2::_ProjectionRead_Skip_TC_Failure_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Failure_Report = _OpCache_with_parameter_Skip_TC_Failure_Report_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_Skip_TC_Failure_Report.find(readState); - if(writeState_ptr != _OpCache_with_parameter_Skip_TC_Failure_Report.end()) { - obsw_M001_2::_ProjectionWrite_Skip_TC_Failure_Report writeState = writeState_ptr->second; - copiedState._apply_update_for_Skip_TC_Failure_Report(writeState); - } else { - copiedState.Skip_TC_Failure_Report(_tmp_1); - obsw_M001_2::_ProjectionWrite_Skip_TC_Failure_Report writeState = copiedState._update_for_Skip_TC_Failure_Report(); - { - std::unique_lock<std::mutex> _ProjectionRead_Skip_TC_Failure_Report_lock(_ProjectionRead_Skip_TC_Failure_Report_mutex); - _OpCache_with_parameter_Skip_TC_Failure_Report.insert({readState, writeState}); - } - } + obsw_M001_2 copiedState = state._copy(); + obsw_M001_2::_ProjectionRead_Skip_TC_Failure_Report readState = state._projected_state_for_Skip_TC_Failure_Report(); + + auto _OpCache_with_parameter_Skip_TC_Failure_Report_ptr = _OpCache_Skip_TC_Failure_Report.find(param); + if(_OpCache_with_parameter_Skip_TC_Failure_Report_ptr == _OpCache_Skip_TC_Failure_Report.end()) { + copiedState.Skip_TC_Failure_Report(_tmp_1); + obsw_M001_2::_ProjectionWrite_Skip_TC_Failure_Report writeState = copiedState._update_for_Skip_TC_Failure_Report(); + std::unordered_map<obsw_M001_2::_ProjectionRead_Skip_TC_Failure_Report, obsw_M001_2::_ProjectionWrite_Skip_TC_Failure_Report, obsw_M001_2::_ProjectionRead_Skip_TC_Failure_Report::Hash, obsw_M001_2::_ProjectionRead_Skip_TC_Failure_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Failure_Report; + _OpCache_with_parameter_Skip_TC_Failure_Report.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_Skip_TC_Failure_Report_lock(_ProjectionRead_Skip_TC_Failure_Report_mutex); + _OpCache_Skip_TC_Failure_Report.insert({param, _OpCache_with_parameter_Skip_TC_Failure_Report}); } - copiedState.stateAccessedVia = "Skip_TC_Failure_Report"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_15 = _trid_15_ptr->second; - for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_15) { - obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param; - - obsw_M001_2 copiedState = state._copy(); - obsw_M001_2::_ProjectionRead_Skip_TC_Failure_Report readState = state._projected_state_for_Skip_TC_Failure_Report(); - - auto _OpCache_with_parameter_Skip_TC_Failure_Report_ptr = _OpCache_Skip_TC_Failure_Report.find(param); - if(_OpCache_with_parameter_Skip_TC_Failure_Report_ptr == _OpCache_Skip_TC_Failure_Report.end()) { + } else { + std::unordered_map<obsw_M001_2::_ProjectionRead_Skip_TC_Failure_Report, obsw_M001_2::_ProjectionWrite_Skip_TC_Failure_Report, obsw_M001_2::_ProjectionRead_Skip_TC_Failure_Report::Hash, obsw_M001_2::_ProjectionRead_Skip_TC_Failure_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Failure_Report = _OpCache_with_parameter_Skip_TC_Failure_Report_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_Skip_TC_Failure_Report.find(readState); + if(writeState_ptr != _OpCache_with_parameter_Skip_TC_Failure_Report.end()) { + obsw_M001_2::_ProjectionWrite_Skip_TC_Failure_Report writeState = writeState_ptr->second; + copiedState._apply_update_for_Skip_TC_Failure_Report(writeState); + } else { copiedState.Skip_TC_Failure_Report(_tmp_1); obsw_M001_2::_ProjectionWrite_Skip_TC_Failure_Report writeState = copiedState._update_for_Skip_TC_Failure_Report(); - std::unordered_map<obsw_M001_2::_ProjectionRead_Skip_TC_Failure_Report, obsw_M001_2::_ProjectionWrite_Skip_TC_Failure_Report, obsw_M001_2::_ProjectionRead_Skip_TC_Failure_Report::Hash, obsw_M001_2::_ProjectionRead_Skip_TC_Failure_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Failure_Report; - _OpCache_with_parameter_Skip_TC_Failure_Report.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_Skip_TC_Failure_Report_lock(_ProjectionRead_Skip_TC_Failure_Report_mutex); - _OpCache_Skip_TC_Failure_Report.insert({param, _OpCache_with_parameter_Skip_TC_Failure_Report}); - } - - } else { - std::unordered_map<obsw_M001_2::_ProjectionRead_Skip_TC_Failure_Report, obsw_M001_2::_ProjectionWrite_Skip_TC_Failure_Report, obsw_M001_2::_ProjectionRead_Skip_TC_Failure_Report::Hash, obsw_M001_2::_ProjectionRead_Skip_TC_Failure_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Failure_Report = _OpCache_with_parameter_Skip_TC_Failure_Report_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_Skip_TC_Failure_Report.find(readState); - if(writeState_ptr != _OpCache_with_parameter_Skip_TC_Failure_Report.end()) { - obsw_M001_2::_ProjectionWrite_Skip_TC_Failure_Report writeState = writeState_ptr->second; - copiedState._apply_update_for_Skip_TC_Failure_Report(writeState); - } else { - copiedState.Skip_TC_Failure_Report(_tmp_1); - obsw_M001_2::_ProjectionWrite_Skip_TC_Failure_Report writeState = copiedState._update_for_Skip_TC_Failure_Report(); - { - std::unique_lock<std::mutex> _ProjectionRead_Skip_TC_Failure_Report_lock(_ProjectionRead_Skip_TC_Failure_Report_mutex); - _OpCache_with_parameter_Skip_TC_Failure_Report.insert({readState, writeState}); - } + _OpCache_with_parameter_Skip_TC_Failure_Report.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "Skip_TC_Failure_Report"; - result.insert(copiedState); + copiedState.stateAccessedVia = "Skip_TC_Failure_Report"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } obsw_M001_2::_ProjectionRead__tr_Drop_TC read__tr_Drop_TC_state = state._projected_state_for__tr_Drop_TC(); + BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_16; auto _trid_16_ptr = _OpCache_tr_Drop_TC.find(read__tr_Drop_TC_state); if(_trid_16_ptr == _OpCache_tr_Drop_TC.end()) { - BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_16 = state._tr_Drop_TC(); - { - std::unique_lock<std::mutex> _ProjectionRead__tr_Drop_TC_lock(_ProjectionRead__tr_Drop_TC_mutex); - _OpCache_tr_Drop_TC.insert({read__tr_Drop_TC_state, _trid_16}); - } - for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_16) { - obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param; - - obsw_M001_2 copiedState = state._copy(); - obsw_M001_2::_ProjectionRead_Drop_TC readState = state._projected_state_for_Drop_TC(); - - auto _OpCache_with_parameter_Drop_TC_ptr = _OpCache_Drop_TC.find(param); - if(_OpCache_with_parameter_Drop_TC_ptr == _OpCache_Drop_TC.end()) { - copiedState.Drop_TC(_tmp_1); - obsw_M001_2::_ProjectionWrite_Drop_TC writeState = copiedState._update_for_Drop_TC(); - std::unordered_map<obsw_M001_2::_ProjectionRead_Drop_TC, obsw_M001_2::_ProjectionWrite_Drop_TC, obsw_M001_2::_ProjectionRead_Drop_TC::Hash, obsw_M001_2::_ProjectionRead_Drop_TC::HashEqual> _OpCache_with_parameter_Drop_TC; - _OpCache_with_parameter_Drop_TC.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_Drop_TC_lock(_ProjectionRead_Drop_TC_mutex); - _OpCache_Drop_TC.insert({param, _OpCache_with_parameter_Drop_TC}); - } - - } else { - std::unordered_map<obsw_M001_2::_ProjectionRead_Drop_TC, obsw_M001_2::_ProjectionWrite_Drop_TC, obsw_M001_2::_ProjectionRead_Drop_TC::Hash, obsw_M001_2::_ProjectionRead_Drop_TC::HashEqual> _OpCache_with_parameter_Drop_TC = _OpCache_with_parameter_Drop_TC_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_Drop_TC.find(readState); - if(writeState_ptr != _OpCache_with_parameter_Drop_TC.end()) { - obsw_M001_2::_ProjectionWrite_Drop_TC writeState = writeState_ptr->second; - copiedState._apply_update_for_Drop_TC(writeState); - } else { - copiedState.Drop_TC(_tmp_1); - obsw_M001_2::_ProjectionWrite_Drop_TC writeState = copiedState._update_for_Drop_TC(); - { - std::unique_lock<std::mutex> _ProjectionRead_Drop_TC_lock(_ProjectionRead_Drop_TC_mutex); - _OpCache_with_parameter_Drop_TC.insert({readState, writeState}); - } - } - } - - copiedState.stateAccessedVia = "Drop_TC"; - result.insert(copiedState); - transitions += 1; + _trid_16 = state._tr_Drop_TC(); + { + std::unique_lock<std::mutex> _ProjectionRead__tr_Drop_TC_lock(_ProjectionRead__tr_Drop_TC_mutex); + _OpCache_tr_Drop_TC.insert({read__tr_Drop_TC_state, _trid_16}); } } else { - BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_16 = _trid_16_ptr->second; - for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_16) { - obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param; + _trid_16 = _trid_16_ptr->second; + } - obsw_M001_2 copiedState = state._copy(); - obsw_M001_2::_ProjectionRead_Drop_TC readState = state._projected_state_for_Drop_TC(); + for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_16) { + obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param; + + obsw_M001_2 copiedState = state._copy(); + obsw_M001_2::_ProjectionRead_Drop_TC readState = state._projected_state_for_Drop_TC(); + + auto _OpCache_with_parameter_Drop_TC_ptr = _OpCache_Drop_TC.find(param); + if(_OpCache_with_parameter_Drop_TC_ptr == _OpCache_Drop_TC.end()) { + copiedState.Drop_TC(_tmp_1); + obsw_M001_2::_ProjectionWrite_Drop_TC writeState = copiedState._update_for_Drop_TC(); + std::unordered_map<obsw_M001_2::_ProjectionRead_Drop_TC, obsw_M001_2::_ProjectionWrite_Drop_TC, obsw_M001_2::_ProjectionRead_Drop_TC::Hash, obsw_M001_2::_ProjectionRead_Drop_TC::HashEqual> _OpCache_with_parameter_Drop_TC; + _OpCache_with_parameter_Drop_TC.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_Drop_TC_lock(_ProjectionRead_Drop_TC_mutex); + _OpCache_Drop_TC.insert({param, _OpCache_with_parameter_Drop_TC}); + } - auto _OpCache_with_parameter_Drop_TC_ptr = _OpCache_Drop_TC.find(param); - if(_OpCache_with_parameter_Drop_TC_ptr == _OpCache_Drop_TC.end()) { + } else { + std::unordered_map<obsw_M001_2::_ProjectionRead_Drop_TC, obsw_M001_2::_ProjectionWrite_Drop_TC, obsw_M001_2::_ProjectionRead_Drop_TC::Hash, obsw_M001_2::_ProjectionRead_Drop_TC::HashEqual> _OpCache_with_parameter_Drop_TC = _OpCache_with_parameter_Drop_TC_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_Drop_TC.find(readState); + if(writeState_ptr != _OpCache_with_parameter_Drop_TC.end()) { + obsw_M001_2::_ProjectionWrite_Drop_TC writeState = writeState_ptr->second; + copiedState._apply_update_for_Drop_TC(writeState); + } else { copiedState.Drop_TC(_tmp_1); obsw_M001_2::_ProjectionWrite_Drop_TC writeState = copiedState._update_for_Drop_TC(); - std::unordered_map<obsw_M001_2::_ProjectionRead_Drop_TC, obsw_M001_2::_ProjectionWrite_Drop_TC, obsw_M001_2::_ProjectionRead_Drop_TC::Hash, obsw_M001_2::_ProjectionRead_Drop_TC::HashEqual> _OpCache_with_parameter_Drop_TC; - _OpCache_with_parameter_Drop_TC.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_Drop_TC_lock(_ProjectionRead_Drop_TC_mutex); - _OpCache_Drop_TC.insert({param, _OpCache_with_parameter_Drop_TC}); - } - - } else { - std::unordered_map<obsw_M001_2::_ProjectionRead_Drop_TC, obsw_M001_2::_ProjectionWrite_Drop_TC, obsw_M001_2::_ProjectionRead_Drop_TC::Hash, obsw_M001_2::_ProjectionRead_Drop_TC::HashEqual> _OpCache_with_parameter_Drop_TC = _OpCache_with_parameter_Drop_TC_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_Drop_TC.find(readState); - if(writeState_ptr != _OpCache_with_parameter_Drop_TC.end()) { - obsw_M001_2::_ProjectionWrite_Drop_TC writeState = writeState_ptr->second; - copiedState._apply_update_for_Drop_TC(writeState); - } else { - copiedState.Drop_TC(_tmp_1); - obsw_M001_2::_ProjectionWrite_Drop_TC writeState = copiedState._update_for_Drop_TC(); - { - std::unique_lock<std::mutex> _ProjectionRead_Drop_TC_lock(_ProjectionRead_Drop_TC_mutex); - _OpCache_with_parameter_Drop_TC.insert({readState, writeState}); - } + _OpCache_with_parameter_Drop_TC.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "Drop_TC"; - result.insert(copiedState); + copiedState.stateAccessedVia = "Drop_TC"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } obsw_M001_2::_ProjectionRead__tr_Produce_TM read__tr_Produce_TM_state = state._projected_state_for__tr_Produce_TM(); + BSet<BTuple<obsw_M001_2::TM_SET, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL >> _trid_17; auto _trid_17_ptr = _OpCache_tr_Produce_TM.find(read__tr_Produce_TM_state); if(_trid_17_ptr == _OpCache_tr_Produce_TM.end()) { - BSet<BTuple<obsw_M001_2::TM_SET, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL >> _trid_17 = state._tr_Produce_TM(); + _trid_17 = state._tr_Produce_TM(); { std::unique_lock<std::mutex> _ProjectionRead__tr_Produce_TM_lock(_ProjectionRead__tr_Produce_TM_mutex); _OpCache_tr_Produce_TM.insert({read__tr_Produce_TM_state, _trid_17}); } - for(const BTuple<obsw_M001_2::TM_SET, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL >& param : _trid_17) { - obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_1 = param.projection2(); - obsw_M001_2::TM_SET _tmp_2 = param.projection1(); - - obsw_M001_2 copiedState = state._copy(); - obsw_M001_2::_ProjectionRead_Produce_TM readState = state._projected_state_for_Produce_TM(); + } else { + _trid_17 = _trid_17_ptr->second; + } - auto _OpCache_with_parameter_Produce_TM_ptr = _OpCache_Produce_TM.find(param); - if(_OpCache_with_parameter_Produce_TM_ptr == _OpCache_Produce_TM.end()) { - copiedState.Produce_TM(_tmp_2, _tmp_1); - obsw_M001_2::_ProjectionWrite_Produce_TM writeState = copiedState._update_for_Produce_TM(); - std::unordered_map<obsw_M001_2::_ProjectionRead_Produce_TM, obsw_M001_2::_ProjectionWrite_Produce_TM, obsw_M001_2::_ProjectionRead_Produce_TM::Hash, obsw_M001_2::_ProjectionRead_Produce_TM::HashEqual> _OpCache_with_parameter_Produce_TM; - _OpCache_with_parameter_Produce_TM.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_Produce_TM_lock(_ProjectionRead_Produce_TM_mutex); - _OpCache_Produce_TM.insert({param, _OpCache_with_parameter_Produce_TM}); - } + for(const BTuple<obsw_M001_2::TM_SET, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL >& param : _trid_17) { + obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_1 = param.projection2(); + obsw_M001_2::TM_SET _tmp_2 = param.projection1(); - } else { - std::unordered_map<obsw_M001_2::_ProjectionRead_Produce_TM, obsw_M001_2::_ProjectionWrite_Produce_TM, obsw_M001_2::_ProjectionRead_Produce_TM::Hash, obsw_M001_2::_ProjectionRead_Produce_TM::HashEqual> _OpCache_with_parameter_Produce_TM = _OpCache_with_parameter_Produce_TM_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_Produce_TM.find(readState); - if(writeState_ptr != _OpCache_with_parameter_Produce_TM.end()) { - obsw_M001_2::_ProjectionWrite_Produce_TM writeState = writeState_ptr->second; - copiedState._apply_update_for_Produce_TM(writeState); - } else { - copiedState.Produce_TM(_tmp_2, _tmp_1); - obsw_M001_2::_ProjectionWrite_Produce_TM writeState = copiedState._update_for_Produce_TM(); - { - std::unique_lock<std::mutex> _ProjectionRead_Produce_TM_lock(_ProjectionRead_Produce_TM_mutex); - _OpCache_with_parameter_Produce_TM.insert({readState, writeState}); - } - } + obsw_M001_2 copiedState = state._copy(); + obsw_M001_2::_ProjectionRead_Produce_TM readState = state._projected_state_for_Produce_TM(); + + auto _OpCache_with_parameter_Produce_TM_ptr = _OpCache_Produce_TM.find(param); + if(_OpCache_with_parameter_Produce_TM_ptr == _OpCache_Produce_TM.end()) { + copiedState.Produce_TM(_tmp_2, _tmp_1); + obsw_M001_2::_ProjectionWrite_Produce_TM writeState = copiedState._update_for_Produce_TM(); + std::unordered_map<obsw_M001_2::_ProjectionRead_Produce_TM, obsw_M001_2::_ProjectionWrite_Produce_TM, obsw_M001_2::_ProjectionRead_Produce_TM::Hash, obsw_M001_2::_ProjectionRead_Produce_TM::HashEqual> _OpCache_with_parameter_Produce_TM; + _OpCache_with_parameter_Produce_TM.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_Produce_TM_lock(_ProjectionRead_Produce_TM_mutex); + _OpCache_Produce_TM.insert({param, _OpCache_with_parameter_Produce_TM}); } - copiedState.stateAccessedVia = "Produce_TM"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<BTuple<obsw_M001_2::TM_SET, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL >> _trid_17 = _trid_17_ptr->second; - for(const BTuple<obsw_M001_2::TM_SET, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL >& param : _trid_17) { - obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_1 = param.projection2(); - obsw_M001_2::TM_SET _tmp_2 = param.projection1(); - - obsw_M001_2 copiedState = state._copy(); - obsw_M001_2::_ProjectionRead_Produce_TM readState = state._projected_state_for_Produce_TM(); - - auto _OpCache_with_parameter_Produce_TM_ptr = _OpCache_Produce_TM.find(param); - if(_OpCache_with_parameter_Produce_TM_ptr == _OpCache_Produce_TM.end()) { + } else { + std::unordered_map<obsw_M001_2::_ProjectionRead_Produce_TM, obsw_M001_2::_ProjectionWrite_Produce_TM, obsw_M001_2::_ProjectionRead_Produce_TM::Hash, obsw_M001_2::_ProjectionRead_Produce_TM::HashEqual> _OpCache_with_parameter_Produce_TM = _OpCache_with_parameter_Produce_TM_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_Produce_TM.find(readState); + if(writeState_ptr != _OpCache_with_parameter_Produce_TM.end()) { + obsw_M001_2::_ProjectionWrite_Produce_TM writeState = writeState_ptr->second; + copiedState._apply_update_for_Produce_TM(writeState); + } else { copiedState.Produce_TM(_tmp_2, _tmp_1); obsw_M001_2::_ProjectionWrite_Produce_TM writeState = copiedState._update_for_Produce_TM(); - std::unordered_map<obsw_M001_2::_ProjectionRead_Produce_TM, obsw_M001_2::_ProjectionWrite_Produce_TM, obsw_M001_2::_ProjectionRead_Produce_TM::Hash, obsw_M001_2::_ProjectionRead_Produce_TM::HashEqual> _OpCache_with_parameter_Produce_TM; - _OpCache_with_parameter_Produce_TM.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_Produce_TM_lock(_ProjectionRead_Produce_TM_mutex); - _OpCache_Produce_TM.insert({param, _OpCache_with_parameter_Produce_TM}); - } - - } else { - std::unordered_map<obsw_M001_2::_ProjectionRead_Produce_TM, obsw_M001_2::_ProjectionWrite_Produce_TM, obsw_M001_2::_ProjectionRead_Produce_TM::Hash, obsw_M001_2::_ProjectionRead_Produce_TM::HashEqual> _OpCache_with_parameter_Produce_TM = _OpCache_with_parameter_Produce_TM_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_Produce_TM.find(readState); - if(writeState_ptr != _OpCache_with_parameter_Produce_TM.end()) { - obsw_M001_2::_ProjectionWrite_Produce_TM writeState = writeState_ptr->second; - copiedState._apply_update_for_Produce_TM(writeState); - } else { - copiedState.Produce_TM(_tmp_2, _tmp_1); - obsw_M001_2::_ProjectionWrite_Produce_TM writeState = copiedState._update_for_Produce_TM(); - { - std::unique_lock<std::mutex> _ProjectionRead_Produce_TM_lock(_ProjectionRead_Produce_TM_mutex); - _OpCache_with_parameter_Produce_TM.insert({readState, writeState}); - } + _OpCache_with_parameter_Produce_TM.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "Produce_TM"; - result.insert(copiedState); + copiedState.stateAccessedVia = "Produce_TM"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } obsw_M001_2::_ProjectionRead__tr_Pass_TM read__tr_Pass_TM_state = state._projected_state_for__tr_Pass_TM(); + BSet<BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_BUFFER >> _trid_18; auto _trid_18_ptr = _OpCache_tr_Pass_TM.find(read__tr_Pass_TM_state); if(_trid_18_ptr == _OpCache_tr_Pass_TM.end()) { - BSet<BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_BUFFER >> _trid_18 = state._tr_Pass_TM(); + _trid_18 = state._tr_Pass_TM(); { std::unique_lock<std::mutex> _ProjectionRead__tr_Pass_TM_lock(_ProjectionRead__tr_Pass_TM_mutex); _OpCache_tr_Pass_TM.insert({read__tr_Pass_TM_state, _trid_18}); } - for(const BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_BUFFER >& param : _trid_18) { - obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_BUFFER _tmp_1 = param.projection2(); - obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_2 = param.projection1(); - - obsw_M001_2 copiedState = state._copy(); - obsw_M001_2::_ProjectionRead_Pass_TM readState = state._projected_state_for_Pass_TM(); + } else { + _trid_18 = _trid_18_ptr->second; + } - auto _OpCache_with_parameter_Pass_TM_ptr = _OpCache_Pass_TM.find(param); - if(_OpCache_with_parameter_Pass_TM_ptr == _OpCache_Pass_TM.end()) { - copiedState.Pass_TM(_tmp_2, _tmp_1); - obsw_M001_2::_ProjectionWrite_Pass_TM writeState = copiedState._update_for_Pass_TM(); - std::unordered_map<obsw_M001_2::_ProjectionRead_Pass_TM, obsw_M001_2::_ProjectionWrite_Pass_TM, obsw_M001_2::_ProjectionRead_Pass_TM::Hash, obsw_M001_2::_ProjectionRead_Pass_TM::HashEqual> _OpCache_with_parameter_Pass_TM; - _OpCache_with_parameter_Pass_TM.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_Pass_TM_lock(_ProjectionRead_Pass_TM_mutex); - _OpCache_Pass_TM.insert({param, _OpCache_with_parameter_Pass_TM}); - } + for(const BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_BUFFER >& param : _trid_18) { + obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_BUFFER _tmp_1 = param.projection2(); + obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_2 = param.projection1(); - } else { - std::unordered_map<obsw_M001_2::_ProjectionRead_Pass_TM, obsw_M001_2::_ProjectionWrite_Pass_TM, obsw_M001_2::_ProjectionRead_Pass_TM::Hash, obsw_M001_2::_ProjectionRead_Pass_TM::HashEqual> _OpCache_with_parameter_Pass_TM = _OpCache_with_parameter_Pass_TM_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_Pass_TM.find(readState); - if(writeState_ptr != _OpCache_with_parameter_Pass_TM.end()) { - obsw_M001_2::_ProjectionWrite_Pass_TM writeState = writeState_ptr->second; - copiedState._apply_update_for_Pass_TM(writeState); - } else { - copiedState.Pass_TM(_tmp_2, _tmp_1); - obsw_M001_2::_ProjectionWrite_Pass_TM writeState = copiedState._update_for_Pass_TM(); - { - std::unique_lock<std::mutex> _ProjectionRead_Pass_TM_lock(_ProjectionRead_Pass_TM_mutex); - _OpCache_with_parameter_Pass_TM.insert({readState, writeState}); - } - } + obsw_M001_2 copiedState = state._copy(); + obsw_M001_2::_ProjectionRead_Pass_TM readState = state._projected_state_for_Pass_TM(); + + auto _OpCache_with_parameter_Pass_TM_ptr = _OpCache_Pass_TM.find(param); + if(_OpCache_with_parameter_Pass_TM_ptr == _OpCache_Pass_TM.end()) { + copiedState.Pass_TM(_tmp_2, _tmp_1); + obsw_M001_2::_ProjectionWrite_Pass_TM writeState = copiedState._update_for_Pass_TM(); + std::unordered_map<obsw_M001_2::_ProjectionRead_Pass_TM, obsw_M001_2::_ProjectionWrite_Pass_TM, obsw_M001_2::_ProjectionRead_Pass_TM::Hash, obsw_M001_2::_ProjectionRead_Pass_TM::HashEqual> _OpCache_with_parameter_Pass_TM; + _OpCache_with_parameter_Pass_TM.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_Pass_TM_lock(_ProjectionRead_Pass_TM_mutex); + _OpCache_Pass_TM.insert({param, _OpCache_with_parameter_Pass_TM}); } - copiedState.stateAccessedVia = "Pass_TM"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_BUFFER >> _trid_18 = _trid_18_ptr->second; - for(const BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_BUFFER >& param : _trid_18) { - obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_BUFFER _tmp_1 = param.projection2(); - obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_2 = param.projection1(); - - obsw_M001_2 copiedState = state._copy(); - obsw_M001_2::_ProjectionRead_Pass_TM readState = state._projected_state_for_Pass_TM(); - - auto _OpCache_with_parameter_Pass_TM_ptr = _OpCache_Pass_TM.find(param); - if(_OpCache_with_parameter_Pass_TM_ptr == _OpCache_Pass_TM.end()) { + } else { + std::unordered_map<obsw_M001_2::_ProjectionRead_Pass_TM, obsw_M001_2::_ProjectionWrite_Pass_TM, obsw_M001_2::_ProjectionRead_Pass_TM::Hash, obsw_M001_2::_ProjectionRead_Pass_TM::HashEqual> _OpCache_with_parameter_Pass_TM = _OpCache_with_parameter_Pass_TM_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_Pass_TM.find(readState); + if(writeState_ptr != _OpCache_with_parameter_Pass_TM.end()) { + obsw_M001_2::_ProjectionWrite_Pass_TM writeState = writeState_ptr->second; + copiedState._apply_update_for_Pass_TM(writeState); + } else { copiedState.Pass_TM(_tmp_2, _tmp_1); obsw_M001_2::_ProjectionWrite_Pass_TM writeState = copiedState._update_for_Pass_TM(); - std::unordered_map<obsw_M001_2::_ProjectionRead_Pass_TM, obsw_M001_2::_ProjectionWrite_Pass_TM, obsw_M001_2::_ProjectionRead_Pass_TM::Hash, obsw_M001_2::_ProjectionRead_Pass_TM::HashEqual> _OpCache_with_parameter_Pass_TM; - _OpCache_with_parameter_Pass_TM.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_Pass_TM_lock(_ProjectionRead_Pass_TM_mutex); - _OpCache_Pass_TM.insert({param, _OpCache_with_parameter_Pass_TM}); - } - - } else { - std::unordered_map<obsw_M001_2::_ProjectionRead_Pass_TM, obsw_M001_2::_ProjectionWrite_Pass_TM, obsw_M001_2::_ProjectionRead_Pass_TM::Hash, obsw_M001_2::_ProjectionRead_Pass_TM::HashEqual> _OpCache_with_parameter_Pass_TM = _OpCache_with_parameter_Pass_TM_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_Pass_TM.find(readState); - if(writeState_ptr != _OpCache_with_parameter_Pass_TM.end()) { - obsw_M001_2::_ProjectionWrite_Pass_TM writeState = writeState_ptr->second; - copiedState._apply_update_for_Pass_TM(writeState); - } else { - copiedState.Pass_TM(_tmp_2, _tmp_1); - obsw_M001_2::_ProjectionWrite_Pass_TM writeState = copiedState._update_for_Pass_TM(); - { - std::unique_lock<std::mutex> _ProjectionRead_Pass_TM_lock(_ProjectionRead_Pass_TM_mutex); - _OpCache_with_parameter_Pass_TM.insert({readState, writeState}); - } + _OpCache_with_parameter_Pass_TM.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "Pass_TM"; - result.insert(copiedState); + copiedState.stateAccessedVia = "Pass_TM"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } obsw_M001_2::_ProjectionRead__tr_Cancel_TM read__tr_Cancel_TM_state = state._projected_state_for__tr_Cancel_TM(); + BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL> _trid_19; auto _trid_19_ptr = _OpCache_tr_Cancel_TM.find(read__tr_Cancel_TM_state); if(_trid_19_ptr == _OpCache_tr_Cancel_TM.end()) { - BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL> _trid_19 = state._tr_Cancel_TM(); + _trid_19 = state._tr_Cancel_TM(); { std::unique_lock<std::mutex> _ProjectionRead__tr_Cancel_TM_lock(_ProjectionRead__tr_Cancel_TM_mutex); _OpCache_tr_Cancel_TM.insert({read__tr_Cancel_TM_state, _trid_19}); } - for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL& param : _trid_19) { - obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_1 = param; - - obsw_M001_2 copiedState = state._copy(); - obsw_M001_2::_ProjectionRead_Cancel_TM readState = state._projected_state_for_Cancel_TM(); + } else { + _trid_19 = _trid_19_ptr->second; + } - auto _OpCache_with_parameter_Cancel_TM_ptr = _OpCache_Cancel_TM.find(param); - if(_OpCache_with_parameter_Cancel_TM_ptr == _OpCache_Cancel_TM.end()) { - copiedState.Cancel_TM(_tmp_1); - obsw_M001_2::_ProjectionWrite_Cancel_TM writeState = copiedState._update_for_Cancel_TM(); - std::unordered_map<obsw_M001_2::_ProjectionRead_Cancel_TM, obsw_M001_2::_ProjectionWrite_Cancel_TM, obsw_M001_2::_ProjectionRead_Cancel_TM::Hash, obsw_M001_2::_ProjectionRead_Cancel_TM::HashEqual> _OpCache_with_parameter_Cancel_TM; - _OpCache_with_parameter_Cancel_TM.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_Cancel_TM_lock(_ProjectionRead_Cancel_TM_mutex); - _OpCache_Cancel_TM.insert({param, _OpCache_with_parameter_Cancel_TM}); - } + for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL& param : _trid_19) { + obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_1 = param; - } else { - std::unordered_map<obsw_M001_2::_ProjectionRead_Cancel_TM, obsw_M001_2::_ProjectionWrite_Cancel_TM, obsw_M001_2::_ProjectionRead_Cancel_TM::Hash, obsw_M001_2::_ProjectionRead_Cancel_TM::HashEqual> _OpCache_with_parameter_Cancel_TM = _OpCache_with_parameter_Cancel_TM_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_Cancel_TM.find(readState); - if(writeState_ptr != _OpCache_with_parameter_Cancel_TM.end()) { - obsw_M001_2::_ProjectionWrite_Cancel_TM writeState = writeState_ptr->second; - copiedState._apply_update_for_Cancel_TM(writeState); - } else { - copiedState.Cancel_TM(_tmp_1); - obsw_M001_2::_ProjectionWrite_Cancel_TM writeState = copiedState._update_for_Cancel_TM(); - { - std::unique_lock<std::mutex> _ProjectionRead_Cancel_TM_lock(_ProjectionRead_Cancel_TM_mutex); - _OpCache_with_parameter_Cancel_TM.insert({readState, writeState}); - } - } + obsw_M001_2 copiedState = state._copy(); + obsw_M001_2::_ProjectionRead_Cancel_TM readState = state._projected_state_for_Cancel_TM(); + + auto _OpCache_with_parameter_Cancel_TM_ptr = _OpCache_Cancel_TM.find(param); + if(_OpCache_with_parameter_Cancel_TM_ptr == _OpCache_Cancel_TM.end()) { + copiedState.Cancel_TM(_tmp_1); + obsw_M001_2::_ProjectionWrite_Cancel_TM writeState = copiedState._update_for_Cancel_TM(); + std::unordered_map<obsw_M001_2::_ProjectionRead_Cancel_TM, obsw_M001_2::_ProjectionWrite_Cancel_TM, obsw_M001_2::_ProjectionRead_Cancel_TM::Hash, obsw_M001_2::_ProjectionRead_Cancel_TM::HashEqual> _OpCache_with_parameter_Cancel_TM; + _OpCache_with_parameter_Cancel_TM.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_Cancel_TM_lock(_ProjectionRead_Cancel_TM_mutex); + _OpCache_Cancel_TM.insert({param, _OpCache_with_parameter_Cancel_TM}); } - copiedState.stateAccessedVia = "Cancel_TM"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL> _trid_19 = _trid_19_ptr->second; - for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL& param : _trid_19) { - obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_1 = param; - - obsw_M001_2 copiedState = state._copy(); - obsw_M001_2::_ProjectionRead_Cancel_TM readState = state._projected_state_for_Cancel_TM(); - - auto _OpCache_with_parameter_Cancel_TM_ptr = _OpCache_Cancel_TM.find(param); - if(_OpCache_with_parameter_Cancel_TM_ptr == _OpCache_Cancel_TM.end()) { + } else { + std::unordered_map<obsw_M001_2::_ProjectionRead_Cancel_TM, obsw_M001_2::_ProjectionWrite_Cancel_TM, obsw_M001_2::_ProjectionRead_Cancel_TM::Hash, obsw_M001_2::_ProjectionRead_Cancel_TM::HashEqual> _OpCache_with_parameter_Cancel_TM = _OpCache_with_parameter_Cancel_TM_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_Cancel_TM.find(readState); + if(writeState_ptr != _OpCache_with_parameter_Cancel_TM.end()) { + obsw_M001_2::_ProjectionWrite_Cancel_TM writeState = writeState_ptr->second; + copiedState._apply_update_for_Cancel_TM(writeState); + } else { copiedState.Cancel_TM(_tmp_1); obsw_M001_2::_ProjectionWrite_Cancel_TM writeState = copiedState._update_for_Cancel_TM(); - std::unordered_map<obsw_M001_2::_ProjectionRead_Cancel_TM, obsw_M001_2::_ProjectionWrite_Cancel_TM, obsw_M001_2::_ProjectionRead_Cancel_TM::Hash, obsw_M001_2::_ProjectionRead_Cancel_TM::HashEqual> _OpCache_with_parameter_Cancel_TM; - _OpCache_with_parameter_Cancel_TM.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_Cancel_TM_lock(_ProjectionRead_Cancel_TM_mutex); - _OpCache_Cancel_TM.insert({param, _OpCache_with_parameter_Cancel_TM}); - } - - } else { - std::unordered_map<obsw_M001_2::_ProjectionRead_Cancel_TM, obsw_M001_2::_ProjectionWrite_Cancel_TM, obsw_M001_2::_ProjectionRead_Cancel_TM::Hash, obsw_M001_2::_ProjectionRead_Cancel_TM::HashEqual> _OpCache_with_parameter_Cancel_TM = _OpCache_with_parameter_Cancel_TM_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_Cancel_TM.find(readState); - if(writeState_ptr != _OpCache_with_parameter_Cancel_TM.end()) { - obsw_M001_2::_ProjectionWrite_Cancel_TM writeState = writeState_ptr->second; - copiedState._apply_update_for_Cancel_TM(writeState); - } else { - copiedState.Cancel_TM(_tmp_1); - obsw_M001_2::_ProjectionWrite_Cancel_TM writeState = copiedState._update_for_Cancel_TM(); - { - std::unique_lock<std::mutex> _ProjectionRead_Cancel_TM_lock(_ProjectionRead_Cancel_TM_mutex); - _OpCache_with_parameter_Cancel_TM.insert({readState, writeState}); - } + _OpCache_with_parameter_Cancel_TM.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "Cancel_TM"; - result.insert(copiedState); + copiedState.stateAccessedVia = "Cancel_TM"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } obsw_M001_2::_ProjectionRead__tr_Drop_TM read__tr_Drop_TM_state = state._projected_state_for__tr_Drop_TM(); + BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL> _trid_20; auto _trid_20_ptr = _OpCache_tr_Drop_TM.find(read__tr_Drop_TM_state); if(_trid_20_ptr == _OpCache_tr_Drop_TM.end()) { - BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL> _trid_20 = state._tr_Drop_TM(); + _trid_20 = state._tr_Drop_TM(); { std::unique_lock<std::mutex> _ProjectionRead__tr_Drop_TM_lock(_ProjectionRead__tr_Drop_TM_mutex); _OpCache_tr_Drop_TM.insert({read__tr_Drop_TM_state, _trid_20}); } - for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL& param : _trid_20) { - obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_1 = param; - - obsw_M001_2 copiedState = state._copy(); - obsw_M001_2::_ProjectionRead_Drop_TM readState = state._projected_state_for_Drop_TM(); + } else { + _trid_20 = _trid_20_ptr->second; + } - auto _OpCache_with_parameter_Drop_TM_ptr = _OpCache_Drop_TM.find(param); - if(_OpCache_with_parameter_Drop_TM_ptr == _OpCache_Drop_TM.end()) { - copiedState.Drop_TM(_tmp_1); - obsw_M001_2::_ProjectionWrite_Drop_TM writeState = copiedState._update_for_Drop_TM(); - std::unordered_map<obsw_M001_2::_ProjectionRead_Drop_TM, obsw_M001_2::_ProjectionWrite_Drop_TM, obsw_M001_2::_ProjectionRead_Drop_TM::Hash, obsw_M001_2::_ProjectionRead_Drop_TM::HashEqual> _OpCache_with_parameter_Drop_TM; - _OpCache_with_parameter_Drop_TM.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_Drop_TM_lock(_ProjectionRead_Drop_TM_mutex); - _OpCache_Drop_TM.insert({param, _OpCache_with_parameter_Drop_TM}); - } + for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL& param : _trid_20) { + obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_1 = param; - } else { - std::unordered_map<obsw_M001_2::_ProjectionRead_Drop_TM, obsw_M001_2::_ProjectionWrite_Drop_TM, obsw_M001_2::_ProjectionRead_Drop_TM::Hash, obsw_M001_2::_ProjectionRead_Drop_TM::HashEqual> _OpCache_with_parameter_Drop_TM = _OpCache_with_parameter_Drop_TM_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_Drop_TM.find(readState); - if(writeState_ptr != _OpCache_with_parameter_Drop_TM.end()) { - obsw_M001_2::_ProjectionWrite_Drop_TM writeState = writeState_ptr->second; - copiedState._apply_update_for_Drop_TM(writeState); - } else { - copiedState.Drop_TM(_tmp_1); - obsw_M001_2::_ProjectionWrite_Drop_TM writeState = copiedState._update_for_Drop_TM(); - { - std::unique_lock<std::mutex> _ProjectionRead_Drop_TM_lock(_ProjectionRead_Drop_TM_mutex); - _OpCache_with_parameter_Drop_TM.insert({readState, writeState}); - } - } + obsw_M001_2 copiedState = state._copy(); + obsw_M001_2::_ProjectionRead_Drop_TM readState = state._projected_state_for_Drop_TM(); + + auto _OpCache_with_parameter_Drop_TM_ptr = _OpCache_Drop_TM.find(param); + if(_OpCache_with_parameter_Drop_TM_ptr == _OpCache_Drop_TM.end()) { + copiedState.Drop_TM(_tmp_1); + obsw_M001_2::_ProjectionWrite_Drop_TM writeState = copiedState._update_for_Drop_TM(); + std::unordered_map<obsw_M001_2::_ProjectionRead_Drop_TM, obsw_M001_2::_ProjectionWrite_Drop_TM, obsw_M001_2::_ProjectionRead_Drop_TM::Hash, obsw_M001_2::_ProjectionRead_Drop_TM::HashEqual> _OpCache_with_parameter_Drop_TM; + _OpCache_with_parameter_Drop_TM.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_Drop_TM_lock(_ProjectionRead_Drop_TM_mutex); + _OpCache_Drop_TM.insert({param, _OpCache_with_parameter_Drop_TM}); } - copiedState.stateAccessedVia = "Drop_TM"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL> _trid_20 = _trid_20_ptr->second; - for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL& param : _trid_20) { - obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_1 = param; - - obsw_M001_2 copiedState = state._copy(); - obsw_M001_2::_ProjectionRead_Drop_TM readState = state._projected_state_for_Drop_TM(); - - auto _OpCache_with_parameter_Drop_TM_ptr = _OpCache_Drop_TM.find(param); - if(_OpCache_with_parameter_Drop_TM_ptr == _OpCache_Drop_TM.end()) { + } else { + std::unordered_map<obsw_M001_2::_ProjectionRead_Drop_TM, obsw_M001_2::_ProjectionWrite_Drop_TM, obsw_M001_2::_ProjectionRead_Drop_TM::Hash, obsw_M001_2::_ProjectionRead_Drop_TM::HashEqual> _OpCache_with_parameter_Drop_TM = _OpCache_with_parameter_Drop_TM_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_Drop_TM.find(readState); + if(writeState_ptr != _OpCache_with_parameter_Drop_TM.end()) { + obsw_M001_2::_ProjectionWrite_Drop_TM writeState = writeState_ptr->second; + copiedState._apply_update_for_Drop_TM(writeState); + } else { copiedState.Drop_TM(_tmp_1); obsw_M001_2::_ProjectionWrite_Drop_TM writeState = copiedState._update_for_Drop_TM(); - std::unordered_map<obsw_M001_2::_ProjectionRead_Drop_TM, obsw_M001_2::_ProjectionWrite_Drop_TM, obsw_M001_2::_ProjectionRead_Drop_TM::Hash, obsw_M001_2::_ProjectionRead_Drop_TM::HashEqual> _OpCache_with_parameter_Drop_TM; - _OpCache_with_parameter_Drop_TM.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_Drop_TM_lock(_ProjectionRead_Drop_TM_mutex); - _OpCache_Drop_TM.insert({param, _OpCache_with_parameter_Drop_TM}); - } - - } else { - std::unordered_map<obsw_M001_2::_ProjectionRead_Drop_TM, obsw_M001_2::_ProjectionWrite_Drop_TM, obsw_M001_2::_ProjectionRead_Drop_TM::Hash, obsw_M001_2::_ProjectionRead_Drop_TM::HashEqual> _OpCache_with_parameter_Drop_TM = _OpCache_with_parameter_Drop_TM_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_Drop_TM.find(readState); - if(writeState_ptr != _OpCache_with_parameter_Drop_TM.end()) { - obsw_M001_2::_ProjectionWrite_Drop_TM writeState = writeState_ptr->second; - copiedState._apply_update_for_Drop_TM(writeState); - } else { - copiedState.Drop_TM(_tmp_1); - obsw_M001_2::_ProjectionWrite_Drop_TM writeState = copiedState._update_for_Drop_TM(); - { - std::unique_lock<std::mutex> _ProjectionRead_Drop_TM_lock(_ProjectionRead_Drop_TM_mutex); - _OpCache_with_parameter_Drop_TM.insert({readState, writeState}); - } + _OpCache_with_parameter_Drop_TM.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "Drop_TM"; - result.insert(copiedState); + copiedState.stateAccessedVia = "Drop_TM"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } obsw_M001_2::_ProjectionRead__tr_env_Deliver_TM read__tr_env_Deliver_TM_state = state._projected_state_for__tr_env_Deliver_TM(); + BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_BUFFER> _trid_21; auto _trid_21_ptr = _OpCache_tr_env_Deliver_TM.find(read__tr_env_Deliver_TM_state); if(_trid_21_ptr == _OpCache_tr_env_Deliver_TM.end()) { - BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_BUFFER> _trid_21 = state._tr_env_Deliver_TM(); + _trid_21 = state._tr_env_Deliver_TM(); { std::unique_lock<std::mutex> _ProjectionRead__tr_env_Deliver_TM_lock(_ProjectionRead__tr_env_Deliver_TM_mutex); _OpCache_tr_env_Deliver_TM.insert({read__tr_env_Deliver_TM_state, _trid_21}); } - for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_BUFFER& param : _trid_21) { - obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_BUFFER _tmp_1 = param; - - obsw_M001_2 copiedState = state._copy(); - obsw_M001_2::_ProjectionRead_env_Deliver_TM readState = state._projected_state_for_env_Deliver_TM(); + } else { + _trid_21 = _trid_21_ptr->second; + } - auto _OpCache_with_parameter_env_Deliver_TM_ptr = _OpCache_env_Deliver_TM.find(param); - if(_OpCache_with_parameter_env_Deliver_TM_ptr == _OpCache_env_Deliver_TM.end()) { - copiedState.env_Deliver_TM(_tmp_1); - obsw_M001_2::_ProjectionWrite_env_Deliver_TM writeState = copiedState._update_for_env_Deliver_TM(); - std::unordered_map<obsw_M001_2::_ProjectionRead_env_Deliver_TM, obsw_M001_2::_ProjectionWrite_env_Deliver_TM, obsw_M001_2::_ProjectionRead_env_Deliver_TM::Hash, obsw_M001_2::_ProjectionRead_env_Deliver_TM::HashEqual> _OpCache_with_parameter_env_Deliver_TM; - _OpCache_with_parameter_env_Deliver_TM.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_env_Deliver_TM_lock(_ProjectionRead_env_Deliver_TM_mutex); - _OpCache_env_Deliver_TM.insert({param, _OpCache_with_parameter_env_Deliver_TM}); - } + for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_BUFFER& param : _trid_21) { + obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_BUFFER _tmp_1 = param; - } else { - std::unordered_map<obsw_M001_2::_ProjectionRead_env_Deliver_TM, obsw_M001_2::_ProjectionWrite_env_Deliver_TM, obsw_M001_2::_ProjectionRead_env_Deliver_TM::Hash, obsw_M001_2::_ProjectionRead_env_Deliver_TM::HashEqual> _OpCache_with_parameter_env_Deliver_TM = _OpCache_with_parameter_env_Deliver_TM_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_env_Deliver_TM.find(readState); - if(writeState_ptr != _OpCache_with_parameter_env_Deliver_TM.end()) { - obsw_M001_2::_ProjectionWrite_env_Deliver_TM writeState = writeState_ptr->second; - copiedState._apply_update_for_env_Deliver_TM(writeState); - } else { - copiedState.env_Deliver_TM(_tmp_1); - obsw_M001_2::_ProjectionWrite_env_Deliver_TM writeState = copiedState._update_for_env_Deliver_TM(); - { - std::unique_lock<std::mutex> _ProjectionRead_env_Deliver_TM_lock(_ProjectionRead_env_Deliver_TM_mutex); - _OpCache_with_parameter_env_Deliver_TM.insert({readState, writeState}); - } - } + obsw_M001_2 copiedState = state._copy(); + obsw_M001_2::_ProjectionRead_env_Deliver_TM readState = state._projected_state_for_env_Deliver_TM(); + + auto _OpCache_with_parameter_env_Deliver_TM_ptr = _OpCache_env_Deliver_TM.find(param); + if(_OpCache_with_parameter_env_Deliver_TM_ptr == _OpCache_env_Deliver_TM.end()) { + copiedState.env_Deliver_TM(_tmp_1); + obsw_M001_2::_ProjectionWrite_env_Deliver_TM writeState = copiedState._update_for_env_Deliver_TM(); + std::unordered_map<obsw_M001_2::_ProjectionRead_env_Deliver_TM, obsw_M001_2::_ProjectionWrite_env_Deliver_TM, obsw_M001_2::_ProjectionRead_env_Deliver_TM::Hash, obsw_M001_2::_ProjectionRead_env_Deliver_TM::HashEqual> _OpCache_with_parameter_env_Deliver_TM; + _OpCache_with_parameter_env_Deliver_TM.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_env_Deliver_TM_lock(_ProjectionRead_env_Deliver_TM_mutex); + _OpCache_env_Deliver_TM.insert({param, _OpCache_with_parameter_env_Deliver_TM}); } - copiedState.stateAccessedVia = "env_Deliver_TM"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_BUFFER> _trid_21 = _trid_21_ptr->second; - for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_BUFFER& param : _trid_21) { - obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_BUFFER _tmp_1 = param; - - obsw_M001_2 copiedState = state._copy(); - obsw_M001_2::_ProjectionRead_env_Deliver_TM readState = state._projected_state_for_env_Deliver_TM(); - - auto _OpCache_with_parameter_env_Deliver_TM_ptr = _OpCache_env_Deliver_TM.find(param); - if(_OpCache_with_parameter_env_Deliver_TM_ptr == _OpCache_env_Deliver_TM.end()) { + } else { + std::unordered_map<obsw_M001_2::_ProjectionRead_env_Deliver_TM, obsw_M001_2::_ProjectionWrite_env_Deliver_TM, obsw_M001_2::_ProjectionRead_env_Deliver_TM::Hash, obsw_M001_2::_ProjectionRead_env_Deliver_TM::HashEqual> _OpCache_with_parameter_env_Deliver_TM = _OpCache_with_parameter_env_Deliver_TM_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_env_Deliver_TM.find(readState); + if(writeState_ptr != _OpCache_with_parameter_env_Deliver_TM.end()) { + obsw_M001_2::_ProjectionWrite_env_Deliver_TM writeState = writeState_ptr->second; + copiedState._apply_update_for_env_Deliver_TM(writeState); + } else { copiedState.env_Deliver_TM(_tmp_1); obsw_M001_2::_ProjectionWrite_env_Deliver_TM writeState = copiedState._update_for_env_Deliver_TM(); - std::unordered_map<obsw_M001_2::_ProjectionRead_env_Deliver_TM, obsw_M001_2::_ProjectionWrite_env_Deliver_TM, obsw_M001_2::_ProjectionRead_env_Deliver_TM::Hash, obsw_M001_2::_ProjectionRead_env_Deliver_TM::HashEqual> _OpCache_with_parameter_env_Deliver_TM; - _OpCache_with_parameter_env_Deliver_TM.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_env_Deliver_TM_lock(_ProjectionRead_env_Deliver_TM_mutex); - _OpCache_env_Deliver_TM.insert({param, _OpCache_with_parameter_env_Deliver_TM}); - } - - } else { - std::unordered_map<obsw_M001_2::_ProjectionRead_env_Deliver_TM, obsw_M001_2::_ProjectionWrite_env_Deliver_TM, obsw_M001_2::_ProjectionRead_env_Deliver_TM::Hash, obsw_M001_2::_ProjectionRead_env_Deliver_TM::HashEqual> _OpCache_with_parameter_env_Deliver_TM = _OpCache_with_parameter_env_Deliver_TM_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_env_Deliver_TM.find(readState); - if(writeState_ptr != _OpCache_with_parameter_env_Deliver_TM.end()) { - obsw_M001_2::_ProjectionWrite_env_Deliver_TM writeState = writeState_ptr->second; - copiedState._apply_update_for_env_Deliver_TM(writeState); - } else { - copiedState.env_Deliver_TM(_tmp_1); - obsw_M001_2::_ProjectionWrite_env_Deliver_TM writeState = copiedState._update_for_env_Deliver_TM(); - { - std::unique_lock<std::mutex> _ProjectionRead_env_Deliver_TM_lock(_ProjectionRead_env_Deliver_TM_mutex); - _OpCache_with_parameter_env_Deliver_TM.insert({readState, writeState}); - } + _OpCache_with_parameter_env_Deliver_TM.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "env_Deliver_TM"; - result.insert(copiedState); + copiedState.stateAccessedVia = "env_Deliver_TM"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } @@ -7527,7 +6847,10 @@ class ModelChecker { copiedState.env_Receive_TC(_tmp_2, _tmp_1); copiedState.stateAccessedVia = "env_Receive_TC"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_BUFFER >> _trid_2 = state._tr_Poll_TC(); for(const BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_BUFFER >& param : _trid_2) { @@ -7538,7 +6861,10 @@ class ModelChecker { copiedState.Poll_TC(_tmp_2, _tmp_1); copiedState.stateAccessedVia = "Poll_TC"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_3 = state._tr_Accept_TC(); for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_3) { @@ -7548,7 +6874,10 @@ class ModelChecker { copiedState.Accept_TC(_tmp_1); copiedState.stateAccessedVia = "Accept_TC"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_4 = state._tr_Reject_TC(); for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_4) { @@ -7558,7 +6887,10 @@ class ModelChecker { copiedState.Reject_TC(_tmp_1); copiedState.stateAccessedVia = "Reject_TC"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<BTuple<BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::TM_SET >, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL >> _trid_5 = state._tr_Report_TC_Acceptance(); for(const BTuple<BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::TM_SET >, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL >& param : _trid_5) { @@ -7571,7 +6903,10 @@ class ModelChecker { copiedState.Report_TC_Acceptance(_tmp_4, _tmp_3, _tmp_1); copiedState.stateAccessedVia = "Report_TC_Acceptance"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_6 = state._tr_Skip_TC_Acceptance_Report(); for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_6) { @@ -7581,7 +6916,10 @@ class ModelChecker { copiedState.Skip_TC_Acceptance_Report(_tmp_1); copiedState.stateAccessedVia = "Skip_TC_Acceptance_Report"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<BTuple<BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::TM_SET >, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL >> _trid_7 = state._tr_Report_TC_Rejection(); for(const BTuple<BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::TM_SET >, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL >& param : _trid_7) { @@ -7594,7 +6932,10 @@ class ModelChecker { copiedState.Report_TC_Rejection(_tmp_4, _tmp_3, _tmp_1); copiedState.stateAccessedVia = "Report_TC_Rejection"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_8 = state._tr_Skip_TC_Rejection_Report(); for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_8) { @@ -7604,7 +6945,10 @@ class ModelChecker { copiedState.Skip_TC_Rejection_Report(_tmp_1); copiedState.stateAccessedVia = "Skip_TC_Rejection_Report"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_9 = state._tr_Execute_TC_Successfully(); for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_9) { @@ -7614,7 +6958,10 @@ class ModelChecker { copiedState.Execute_TC_Successfully(_tmp_1); copiedState.stateAccessedVia = "Execute_TC_Successfully"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_10 = state._tr_Reset_TM_Buffer(); for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_10) { @@ -7624,7 +6971,10 @@ class ModelChecker { copiedState.Reset_TM_Buffer(_tmp_1); copiedState.stateAccessedVia = "Reset_TM_Buffer"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_11 = state._tr_Fail_TC_Execution(); for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_11) { @@ -7634,7 +6984,10 @@ class ModelChecker { copiedState.Fail_TC_Execution(_tmp_1); copiedState.stateAccessedVia = "Fail_TC_Execution"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<BTuple<BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::TM_SET >, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL >> _trid_12 = state._tr_Report_TC_Execution_Success(); for(const BTuple<BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::TM_SET >, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL >& param : _trid_12) { @@ -7647,7 +7000,10 @@ class ModelChecker { copiedState.Report_TC_Execution_Success(_tmp_4, _tmp_3, _tmp_1); copiedState.stateAccessedVia = "Report_TC_Execution_Success"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_13 = state._tr_Skip_TC_Success_Report(); for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_13) { @@ -7657,7 +7013,10 @@ class ModelChecker { copiedState.Skip_TC_Success_Report(_tmp_1); copiedState.stateAccessedVia = "Skip_TC_Success_Report"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<BTuple<BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::TM_SET >, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL >> _trid_14 = state._tr_Report_TC_Execution_Failure(); for(const BTuple<BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::TM_SET >, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL >& param : _trid_14) { @@ -7670,7 +7029,10 @@ class ModelChecker { copiedState.Report_TC_Execution_Failure(_tmp_4, _tmp_3, _tmp_1); copiedState.stateAccessedVia = "Report_TC_Execution_Failure"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_15 = state._tr_Skip_TC_Failure_Report(); for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_15) { @@ -7680,7 +7042,10 @@ class ModelChecker { copiedState.Skip_TC_Failure_Report(_tmp_1); copiedState.stateAccessedVia = "Skip_TC_Failure_Report"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_16 = state._tr_Drop_TC(); for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_16) { @@ -7690,7 +7055,10 @@ class ModelChecker { copiedState.Drop_TC(_tmp_1); copiedState.stateAccessedVia = "Drop_TC"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<BTuple<obsw_M001_2::TM_SET, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL >> _trid_17 = state._tr_Produce_TM(); for(const BTuple<obsw_M001_2::TM_SET, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL >& param : _trid_17) { @@ -7701,7 +7069,10 @@ class ModelChecker { copiedState.Produce_TM(_tmp_2, _tmp_1); copiedState.stateAccessedVia = "Produce_TM"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_BUFFER >> _trid_18 = state._tr_Pass_TM(); for(const BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_BUFFER >& param : _trid_18) { @@ -7712,7 +7083,10 @@ class ModelChecker { copiedState.Pass_TM(_tmp_2, _tmp_1); copiedState.stateAccessedVia = "Pass_TM"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL> _trid_19 = state._tr_Cancel_TM(); for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL& param : _trid_19) { @@ -7722,7 +7096,10 @@ class ModelChecker { copiedState.Cancel_TM(_tmp_1); copiedState.stateAccessedVia = "Cancel_TM"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL> _trid_20 = state._tr_Drop_TM(); for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL& param : _trid_20) { @@ -7732,7 +7109,10 @@ class ModelChecker { copiedState.Drop_TM(_tmp_1); copiedState.stateAccessedVia = "Drop_TM"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_BUFFER> _trid_21 = state._tr_env_Deliver_TM(); for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_BUFFER& param : _trid_21) { @@ -7742,7 +7122,10 @@ class ModelChecker { copiedState.env_Deliver_TM(_tmp_1); copiedState.stateAccessedVia = "env_Deliver_TM"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } } diff --git a/benchmarks/model_checking_opreuse/C++/prob_oneway8seq.cpp b/benchmarks/model_checking_opreuse/C++/prob_oneway8seq.cpp index 60fb0372e970055b4eb398490753f3a3ae128023..93255438c38e526fff2f918e91042ee38b5497b2 100644 --- a/benchmarks/model_checking_opreuse/C++/prob_oneway8seq.cpp +++ b/benchmarks/model_checking_opreuse/C++/prob_oneway8seq.cpp @@ -10,7 +10,6 @@ #include <atomic> #include <any> #include <mutex> -#include <shared_mutex> #include <future> #include <boost/asio/post.hpp> #include <boost/asio/thread_pool.hpp> @@ -3556,12 +3555,16 @@ class ModelChecker { states.insert(machine); unvisitedStates.push_back(machine); - std::atomic<bool> stopThreads(false); + std::atomic<bool> stopThreads; + stopThreads = false; std::atomic<int> possibleQueueChanges; possibleQueueChanges = 0; - while(!unvisitedStates.empty() && !stopThreads.load()) { - possibleQueueChanges.fetch_add(1); + std::atomic<bool> waitFlag; + waitFlag = true; + + while(!unvisitedStates.empty() && !stopThreads) { + possibleQueueChanges += 1; prob_oneway8seq state = next(); std::packaged_task<void()> task([&, state] { std::unordered_set<prob_oneway8seq, prob_oneway8seq::Hash, prob_oneway8seq::HashEqual> nextStates = generateNextStates(state); @@ -3582,12 +3585,14 @@ class ModelChecker { } } - possibleQueueChanges.fetch_sub(1); { std::unique_lock<std::mutex> lock(mutex); - if (!unvisitedStates.empty() || possibleQueueChanges.load() == 0) { + possibleQueueChanges -= 1; + int running = possibleQueueChanges; + if (!unvisitedStates.empty() || running == 0) { { std::unique_lock<std::mutex> lock(waitMutex); + waitFlag = false; waitCV.notify_one(); } } @@ -3597,24 +3602,27 @@ class ModelChecker { if(invariantViolated(state)) { invariantViolatedBool = true; counterExampleState = state; - stopThreads.store(true); + stopThreads = true; } if(nextStates.empty()) { deadlockDetected = true; counterExampleState = state; - stopThreads.store(true); + stopThreads = true; } }); + waitFlag = true; boost::asio::post(workers, std::move(task)); { std::unique_lock<std::mutex> lock(waitMutex); - waitCV.wait(lock, [&] { - return !unvisitedStates.empty() || possibleQueueChanges == 0; - }); + if(unvisitedStates.empty() && possibleQueueChanges > 0) { + waitCV.wait(lock, [&] { + return waitFlag == false; + }); + } } } workers.join(); @@ -3703,7 +3711,10 @@ class ModelChecker { copiedState.stateAccessedVia = "move0"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } prob_oneway8seq::_ProjectionRead__tr_move1 read__tr_move1_state = state._projected_state_for__tr_move1(); bool _trid_2; @@ -3750,7 +3761,10 @@ class ModelChecker { copiedState.stateAccessedVia = "move1"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } prob_oneway8seq::_ProjectionRead__tr_move2 read__tr_move2_state = state._projected_state_for__tr_move2(); bool _trid_3; @@ -3797,7 +3811,10 @@ class ModelChecker { copiedState.stateAccessedVia = "move2"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } prob_oneway8seq::_ProjectionRead__tr_move3 read__tr_move3_state = state._projected_state_for__tr_move3(); bool _trid_4; @@ -3844,7 +3861,10 @@ class ModelChecker { copiedState.stateAccessedVia = "move3"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } prob_oneway8seq::_ProjectionRead__tr_move4 read__tr_move4_state = state._projected_state_for__tr_move4(); bool _trid_5; @@ -3891,7 +3911,10 @@ class ModelChecker { copiedState.stateAccessedVia = "move4"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } prob_oneway8seq::_ProjectionRead__tr_move5 read__tr_move5_state = state._projected_state_for__tr_move5(); bool _trid_6; @@ -3938,7 +3961,10 @@ class ModelChecker { copiedState.stateAccessedVia = "move5"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } prob_oneway8seq::_ProjectionRead__tr_move6 read__tr_move6_state = state._projected_state_for__tr_move6(); bool _trid_7; @@ -3985,7 +4011,10 @@ class ModelChecker { copiedState.stateAccessedVia = "move6"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } prob_oneway8seq::_ProjectionRead__tr_move7 read__tr_move7_state = state._projected_state_for__tr_move7(); bool _trid_8; @@ -4032,7 +4061,10 @@ class ModelChecker { copiedState.stateAccessedVia = "move7"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } prob_oneway8seq::_ProjectionRead__tr_arrived read__tr_arrived_state = state._projected_state_for__tr_arrived(); bool _trid_9; @@ -4079,7 +4111,10 @@ class ModelChecker { copiedState.stateAccessedVia = "arrived"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } } else { @@ -4088,63 +4123,90 @@ class ModelChecker { copiedState.move0(); copiedState.stateAccessedVia = "move0"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } if(state._tr_move1()) { prob_oneway8seq copiedState = state._copy(); copiedState.move1(); copiedState.stateAccessedVia = "move1"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } if(state._tr_move2()) { prob_oneway8seq copiedState = state._copy(); copiedState.move2(); copiedState.stateAccessedVia = "move2"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } if(state._tr_move3()) { prob_oneway8seq copiedState = state._copy(); copiedState.move3(); copiedState.stateAccessedVia = "move3"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } if(state._tr_move4()) { prob_oneway8seq copiedState = state._copy(); copiedState.move4(); copiedState.stateAccessedVia = "move4"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } if(state._tr_move5()) { prob_oneway8seq copiedState = state._copy(); copiedState.move5(); copiedState.stateAccessedVia = "move5"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } if(state._tr_move6()) { prob_oneway8seq copiedState = state._copy(); copiedState.move6(); copiedState.stateAccessedVia = "move6"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } if(state._tr_move7()) { prob_oneway8seq copiedState = state._copy(); copiedState.move7(); copiedState.stateAccessedVia = "move7"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } if(state._tr_arrived()) { prob_oneway8seq copiedState = state._copy(); copiedState.arrived(); copiedState.stateAccessedVia = "arrived"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } } diff --git a/benchmarks/model_checking_opreuse/C++/rether.cpp b/benchmarks/model_checking_opreuse/C++/rether.cpp index facfa6718f4ccc381075bfd2738a8d6f790d48df..4290bdc23dd6b2a8b33063ce53b70eb4f8511668 100644 --- a/benchmarks/model_checking_opreuse/C++/rether.cpp +++ b/benchmarks/model_checking_opreuse/C++/rether.cpp @@ -10,7 +10,6 @@ #include <atomic> #include <any> #include <mutex> -#include <shared_mutex> #include <future> #include <boost/asio/post.hpp> #include <boost/asio/thread_pool.hpp> @@ -2273,12 +2272,16 @@ class ModelChecker { states.insert(machine); unvisitedStates.push_back(machine); - std::atomic<bool> stopThreads(false); + std::atomic<bool> stopThreads; + stopThreads = false; std::atomic<int> possibleQueueChanges; possibleQueueChanges = 0; - while(!unvisitedStates.empty() && !stopThreads.load()) { - possibleQueueChanges.fetch_add(1); + std::atomic<bool> waitFlag; + waitFlag = true; + + while(!unvisitedStates.empty() && !stopThreads) { + possibleQueueChanges += 1; rether state = next(); std::packaged_task<void()> task([&, state] { std::unordered_set<rether, rether::Hash, rether::HashEqual> nextStates = generateNextStates(state); @@ -2299,12 +2302,14 @@ class ModelChecker { } } - possibleQueueChanges.fetch_sub(1); { std::unique_lock<std::mutex> lock(mutex); - if (!unvisitedStates.empty() || possibleQueueChanges.load() == 0) { + possibleQueueChanges -= 1; + int running = possibleQueueChanges; + if (!unvisitedStates.empty() || running == 0) { { std::unique_lock<std::mutex> lock(waitMutex); + waitFlag = false; waitCV.notify_one(); } } @@ -2314,24 +2319,27 @@ class ModelChecker { if(invariantViolated(state)) { invariantViolatedBool = true; counterExampleState = state; - stopThreads.store(true); + stopThreads = true; } if(nextStates.empty()) { deadlockDetected = true; counterExampleState = state; - stopThreads.store(true); + stopThreads = true; } }); + waitFlag = true; boost::asio::post(workers, std::move(task)); { std::unique_lock<std::mutex> lock(waitMutex); - waitCV.wait(lock, [&] { - return !unvisitedStates.empty() || possibleQueueChanges == 0; - }); + if(unvisitedStates.empty() && possibleQueueChanges > 0) { + waitCV.wait(lock, [&] { + return waitFlag == false; + }); + } } } workers.join(); @@ -2376,696 +2384,433 @@ class ModelChecker { std::unordered_set<rether, rether::Hash, rether::HashEqual> result = std::unordered_set<rether, rether::Hash, rether::HashEqual>(); if(isCaching) { rether::_ProjectionRead__tr_elapse_time read__tr_elapse_time_state = state._projected_state_for__tr_elapse_time(); + BSet<BTuple<rether::Slots, rether::Slots >> _trid_1; auto _trid_1_ptr = _OpCache_tr_elapse_time.find(read__tr_elapse_time_state); if(_trid_1_ptr == _OpCache_tr_elapse_time.end()) { - BSet<BTuple<rether::Slots, rether::Slots >> _trid_1 = state._tr_elapse_time(); + _trid_1 = state._tr_elapse_time(); { std::unique_lock<std::mutex> _ProjectionRead__tr_elapse_time_lock(_ProjectionRead__tr_elapse_time_mutex); _OpCache_tr_elapse_time.insert({read__tr_elapse_time_state, _trid_1}); } - for(const BTuple<rether::Slots, rether::Slots >& param : _trid_1) { - rether::Slots _tmp_1 = param.projection2(); - rether::Slots _tmp_2 = param.projection1(); - - rether copiedState = state._copy(); - rether::_ProjectionRead_elapse_time readState = state._projected_state_for_elapse_time(); + } else { + _trid_1 = _trid_1_ptr->second; + } - auto _OpCache_with_parameter_elapse_time_ptr = _OpCache_elapse_time.find(param); - if(_OpCache_with_parameter_elapse_time_ptr == _OpCache_elapse_time.end()) { - copiedState.elapse_time(_tmp_2, _tmp_1); - rether::_ProjectionWrite_elapse_time writeState = copiedState._update_for_elapse_time(); - std::unordered_map<rether::_ProjectionRead_elapse_time, rether::_ProjectionWrite_elapse_time, rether::_ProjectionRead_elapse_time::Hash, rether::_ProjectionRead_elapse_time::HashEqual> _OpCache_with_parameter_elapse_time; - _OpCache_with_parameter_elapse_time.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_elapse_time_lock(_ProjectionRead_elapse_time_mutex); - _OpCache_elapse_time.insert({param, _OpCache_with_parameter_elapse_time}); - } + for(const BTuple<rether::Slots, rether::Slots >& param : _trid_1) { + rether::Slots _tmp_1 = param.projection2(); + rether::Slots _tmp_2 = param.projection1(); - } else { - std::unordered_map<rether::_ProjectionRead_elapse_time, rether::_ProjectionWrite_elapse_time, rether::_ProjectionRead_elapse_time::Hash, rether::_ProjectionRead_elapse_time::HashEqual> _OpCache_with_parameter_elapse_time = _OpCache_with_parameter_elapse_time_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_elapse_time.find(readState); - if(writeState_ptr != _OpCache_with_parameter_elapse_time.end()) { - rether::_ProjectionWrite_elapse_time writeState = writeState_ptr->second; - copiedState._apply_update_for_elapse_time(writeState); - } else { - copiedState.elapse_time(_tmp_2, _tmp_1); - rether::_ProjectionWrite_elapse_time writeState = copiedState._update_for_elapse_time(); - { - std::unique_lock<std::mutex> _ProjectionRead_elapse_time_lock(_ProjectionRead_elapse_time_mutex); - _OpCache_with_parameter_elapse_time.insert({readState, writeState}); - } - } + rether copiedState = state._copy(); + rether::_ProjectionRead_elapse_time readState = state._projected_state_for_elapse_time(); + + auto _OpCache_with_parameter_elapse_time_ptr = _OpCache_elapse_time.find(param); + if(_OpCache_with_parameter_elapse_time_ptr == _OpCache_elapse_time.end()) { + copiedState.elapse_time(_tmp_2, _tmp_1); + rether::_ProjectionWrite_elapse_time writeState = copiedState._update_for_elapse_time(); + std::unordered_map<rether::_ProjectionRead_elapse_time, rether::_ProjectionWrite_elapse_time, rether::_ProjectionRead_elapse_time::Hash, rether::_ProjectionRead_elapse_time::HashEqual> _OpCache_with_parameter_elapse_time; + _OpCache_with_parameter_elapse_time.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_elapse_time_lock(_ProjectionRead_elapse_time_mutex); + _OpCache_elapse_time.insert({param, _OpCache_with_parameter_elapse_time}); } - copiedState.stateAccessedVia = "elapse_time"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<BTuple<rether::Slots, rether::Slots >> _trid_1 = _trid_1_ptr->second; - for(const BTuple<rether::Slots, rether::Slots >& param : _trid_1) { - rether::Slots _tmp_1 = param.projection2(); - rether::Slots _tmp_2 = param.projection1(); - - rether copiedState = state._copy(); - rether::_ProjectionRead_elapse_time readState = state._projected_state_for_elapse_time(); - - auto _OpCache_with_parameter_elapse_time_ptr = _OpCache_elapse_time.find(param); - if(_OpCache_with_parameter_elapse_time_ptr == _OpCache_elapse_time.end()) { + } else { + std::unordered_map<rether::_ProjectionRead_elapse_time, rether::_ProjectionWrite_elapse_time, rether::_ProjectionRead_elapse_time::Hash, rether::_ProjectionRead_elapse_time::HashEqual> _OpCache_with_parameter_elapse_time = _OpCache_with_parameter_elapse_time_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_elapse_time.find(readState); + if(writeState_ptr != _OpCache_with_parameter_elapse_time.end()) { + rether::_ProjectionWrite_elapse_time writeState = writeState_ptr->second; + copiedState._apply_update_for_elapse_time(writeState); + } else { copiedState.elapse_time(_tmp_2, _tmp_1); rether::_ProjectionWrite_elapse_time writeState = copiedState._update_for_elapse_time(); - std::unordered_map<rether::_ProjectionRead_elapse_time, rether::_ProjectionWrite_elapse_time, rether::_ProjectionRead_elapse_time::Hash, rether::_ProjectionRead_elapse_time::HashEqual> _OpCache_with_parameter_elapse_time; - _OpCache_with_parameter_elapse_time.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_elapse_time_lock(_ProjectionRead_elapse_time_mutex); - _OpCache_elapse_time.insert({param, _OpCache_with_parameter_elapse_time}); - } - - } else { - std::unordered_map<rether::_ProjectionRead_elapse_time, rether::_ProjectionWrite_elapse_time, rether::_ProjectionRead_elapse_time::Hash, rether::_ProjectionRead_elapse_time::HashEqual> _OpCache_with_parameter_elapse_time = _OpCache_with_parameter_elapse_time_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_elapse_time.find(readState); - if(writeState_ptr != _OpCache_with_parameter_elapse_time.end()) { - rether::_ProjectionWrite_elapse_time writeState = writeState_ptr->second; - copiedState._apply_update_for_elapse_time(writeState); - } else { - copiedState.elapse_time(_tmp_2, _tmp_1); - rether::_ProjectionWrite_elapse_time writeState = copiedState._update_for_elapse_time(); - { - std::unique_lock<std::mutex> _ProjectionRead_elapse_time_lock(_ProjectionRead_elapse_time_mutex); - _OpCache_with_parameter_elapse_time.insert({readState, writeState}); - } + _OpCache_with_parameter_elapse_time.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "elapse_time"; - result.insert(copiedState); + copiedState.stateAccessedVia = "elapse_time"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } rether::_ProjectionRead__tr_reserve read__tr_reserve_state = state._projected_state_for__tr_reserve(); + BSet<BTuple<rether::Nodes, rether::Slots >> _trid_2; auto _trid_2_ptr = _OpCache_tr_reserve.find(read__tr_reserve_state); if(_trid_2_ptr == _OpCache_tr_reserve.end()) { - BSet<BTuple<rether::Nodes, rether::Slots >> _trid_2 = state._tr_reserve(); + _trid_2 = state._tr_reserve(); { std::unique_lock<std::mutex> _ProjectionRead__tr_reserve_lock(_ProjectionRead__tr_reserve_mutex); _OpCache_tr_reserve.insert({read__tr_reserve_state, _trid_2}); } - for(const BTuple<rether::Nodes, rether::Slots >& param : _trid_2) { - rether::Slots _tmp_1 = param.projection2(); - rether::Nodes _tmp_2 = param.projection1(); - - rether copiedState = state._copy(); - rether::_ProjectionRead_reserve readState = state._projected_state_for_reserve(); + } else { + _trid_2 = _trid_2_ptr->second; + } - auto _OpCache_with_parameter_reserve_ptr = _OpCache_reserve.find(param); - if(_OpCache_with_parameter_reserve_ptr == _OpCache_reserve.end()) { - copiedState.reserve(_tmp_2, _tmp_1); - rether::_ProjectionWrite_reserve writeState = copiedState._update_for_reserve(); - std::unordered_map<rether::_ProjectionRead_reserve, rether::_ProjectionWrite_reserve, rether::_ProjectionRead_reserve::Hash, rether::_ProjectionRead_reserve::HashEqual> _OpCache_with_parameter_reserve; - _OpCache_with_parameter_reserve.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_reserve_lock(_ProjectionRead_reserve_mutex); - _OpCache_reserve.insert({param, _OpCache_with_parameter_reserve}); - } + for(const BTuple<rether::Nodes, rether::Slots >& param : _trid_2) { + rether::Slots _tmp_1 = param.projection2(); + rether::Nodes _tmp_2 = param.projection1(); - } else { - std::unordered_map<rether::_ProjectionRead_reserve, rether::_ProjectionWrite_reserve, rether::_ProjectionRead_reserve::Hash, rether::_ProjectionRead_reserve::HashEqual> _OpCache_with_parameter_reserve = _OpCache_with_parameter_reserve_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_reserve.find(readState); - if(writeState_ptr != _OpCache_with_parameter_reserve.end()) { - rether::_ProjectionWrite_reserve writeState = writeState_ptr->second; - copiedState._apply_update_for_reserve(writeState); - } else { - copiedState.reserve(_tmp_2, _tmp_1); - rether::_ProjectionWrite_reserve writeState = copiedState._update_for_reserve(); - { - std::unique_lock<std::mutex> _ProjectionRead_reserve_lock(_ProjectionRead_reserve_mutex); - _OpCache_with_parameter_reserve.insert({readState, writeState}); - } - } + rether copiedState = state._copy(); + rether::_ProjectionRead_reserve readState = state._projected_state_for_reserve(); + + auto _OpCache_with_parameter_reserve_ptr = _OpCache_reserve.find(param); + if(_OpCache_with_parameter_reserve_ptr == _OpCache_reserve.end()) { + copiedState.reserve(_tmp_2, _tmp_1); + rether::_ProjectionWrite_reserve writeState = copiedState._update_for_reserve(); + std::unordered_map<rether::_ProjectionRead_reserve, rether::_ProjectionWrite_reserve, rether::_ProjectionRead_reserve::Hash, rether::_ProjectionRead_reserve::HashEqual> _OpCache_with_parameter_reserve; + _OpCache_with_parameter_reserve.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_reserve_lock(_ProjectionRead_reserve_mutex); + _OpCache_reserve.insert({param, _OpCache_with_parameter_reserve}); } - copiedState.stateAccessedVia = "reserve"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<BTuple<rether::Nodes, rether::Slots >> _trid_2 = _trid_2_ptr->second; - for(const BTuple<rether::Nodes, rether::Slots >& param : _trid_2) { - rether::Slots _tmp_1 = param.projection2(); - rether::Nodes _tmp_2 = param.projection1(); - - rether copiedState = state._copy(); - rether::_ProjectionRead_reserve readState = state._projected_state_for_reserve(); - - auto _OpCache_with_parameter_reserve_ptr = _OpCache_reserve.find(param); - if(_OpCache_with_parameter_reserve_ptr == _OpCache_reserve.end()) { + } else { + std::unordered_map<rether::_ProjectionRead_reserve, rether::_ProjectionWrite_reserve, rether::_ProjectionRead_reserve::Hash, rether::_ProjectionRead_reserve::HashEqual> _OpCache_with_parameter_reserve = _OpCache_with_parameter_reserve_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_reserve.find(readState); + if(writeState_ptr != _OpCache_with_parameter_reserve.end()) { + rether::_ProjectionWrite_reserve writeState = writeState_ptr->second; + copiedState._apply_update_for_reserve(writeState); + } else { copiedState.reserve(_tmp_2, _tmp_1); rether::_ProjectionWrite_reserve writeState = copiedState._update_for_reserve(); - std::unordered_map<rether::_ProjectionRead_reserve, rether::_ProjectionWrite_reserve, rether::_ProjectionRead_reserve::Hash, rether::_ProjectionRead_reserve::HashEqual> _OpCache_with_parameter_reserve; - _OpCache_with_parameter_reserve.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_reserve_lock(_ProjectionRead_reserve_mutex); - _OpCache_reserve.insert({param, _OpCache_with_parameter_reserve}); - } - - } else { - std::unordered_map<rether::_ProjectionRead_reserve, rether::_ProjectionWrite_reserve, rether::_ProjectionRead_reserve::Hash, rether::_ProjectionRead_reserve::HashEqual> _OpCache_with_parameter_reserve = _OpCache_with_parameter_reserve_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_reserve.find(readState); - if(writeState_ptr != _OpCache_with_parameter_reserve.end()) { - rether::_ProjectionWrite_reserve writeState = writeState_ptr->second; - copiedState._apply_update_for_reserve(writeState); - } else { - copiedState.reserve(_tmp_2, _tmp_1); - rether::_ProjectionWrite_reserve writeState = copiedState._update_for_reserve(); - { - std::unique_lock<std::mutex> _ProjectionRead_reserve_lock(_ProjectionRead_reserve_mutex); - _OpCache_with_parameter_reserve.insert({readState, writeState}); - } + _OpCache_with_parameter_reserve.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "reserve"; - result.insert(copiedState); + copiedState.stateAccessedVia = "reserve"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } rether::_ProjectionRead__tr_release read__tr_release_state = state._projected_state_for__tr_release(); + BSet<BTuple<rether::Nodes, rether::Slots >> _trid_3; auto _trid_3_ptr = _OpCache_tr_release.find(read__tr_release_state); if(_trid_3_ptr == _OpCache_tr_release.end()) { - BSet<BTuple<rether::Nodes, rether::Slots >> _trid_3 = state._tr_release(); + _trid_3 = state._tr_release(); { std::unique_lock<std::mutex> _ProjectionRead__tr_release_lock(_ProjectionRead__tr_release_mutex); _OpCache_tr_release.insert({read__tr_release_state, _trid_3}); } - for(const BTuple<rether::Nodes, rether::Slots >& param : _trid_3) { - rether::Slots _tmp_1 = param.projection2(); - rether::Nodes _tmp_2 = param.projection1(); - - rether copiedState = state._copy(); - rether::_ProjectionRead_release readState = state._projected_state_for_release(); + } else { + _trid_3 = _trid_3_ptr->second; + } - auto _OpCache_with_parameter_release_ptr = _OpCache_release.find(param); - if(_OpCache_with_parameter_release_ptr == _OpCache_release.end()) { - copiedState.release(_tmp_2, _tmp_1); - rether::_ProjectionWrite_release writeState = copiedState._update_for_release(); - std::unordered_map<rether::_ProjectionRead_release, rether::_ProjectionWrite_release, rether::_ProjectionRead_release::Hash, rether::_ProjectionRead_release::HashEqual> _OpCache_with_parameter_release; - _OpCache_with_parameter_release.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_release_lock(_ProjectionRead_release_mutex); - _OpCache_release.insert({param, _OpCache_with_parameter_release}); - } + for(const BTuple<rether::Nodes, rether::Slots >& param : _trid_3) { + rether::Slots _tmp_1 = param.projection2(); + rether::Nodes _tmp_2 = param.projection1(); - } else { - std::unordered_map<rether::_ProjectionRead_release, rether::_ProjectionWrite_release, rether::_ProjectionRead_release::Hash, rether::_ProjectionRead_release::HashEqual> _OpCache_with_parameter_release = _OpCache_with_parameter_release_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_release.find(readState); - if(writeState_ptr != _OpCache_with_parameter_release.end()) { - rether::_ProjectionWrite_release writeState = writeState_ptr->second; - copiedState._apply_update_for_release(writeState); - } else { - copiedState.release(_tmp_2, _tmp_1); - rether::_ProjectionWrite_release writeState = copiedState._update_for_release(); - { - std::unique_lock<std::mutex> _ProjectionRead_release_lock(_ProjectionRead_release_mutex); - _OpCache_with_parameter_release.insert({readState, writeState}); - } - } + rether copiedState = state._copy(); + rether::_ProjectionRead_release readState = state._projected_state_for_release(); + + auto _OpCache_with_parameter_release_ptr = _OpCache_release.find(param); + if(_OpCache_with_parameter_release_ptr == _OpCache_release.end()) { + copiedState.release(_tmp_2, _tmp_1); + rether::_ProjectionWrite_release writeState = copiedState._update_for_release(); + std::unordered_map<rether::_ProjectionRead_release, rether::_ProjectionWrite_release, rether::_ProjectionRead_release::Hash, rether::_ProjectionRead_release::HashEqual> _OpCache_with_parameter_release; + _OpCache_with_parameter_release.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_release_lock(_ProjectionRead_release_mutex); + _OpCache_release.insert({param, _OpCache_with_parameter_release}); } - copiedState.stateAccessedVia = "release"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<BTuple<rether::Nodes, rether::Slots >> _trid_3 = _trid_3_ptr->second; - for(const BTuple<rether::Nodes, rether::Slots >& param : _trid_3) { - rether::Slots _tmp_1 = param.projection2(); - rether::Nodes _tmp_2 = param.projection1(); - - rether copiedState = state._copy(); - rether::_ProjectionRead_release readState = state._projected_state_for_release(); - - auto _OpCache_with_parameter_release_ptr = _OpCache_release.find(param); - if(_OpCache_with_parameter_release_ptr == _OpCache_release.end()) { + } else { + std::unordered_map<rether::_ProjectionRead_release, rether::_ProjectionWrite_release, rether::_ProjectionRead_release::Hash, rether::_ProjectionRead_release::HashEqual> _OpCache_with_parameter_release = _OpCache_with_parameter_release_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_release.find(readState); + if(writeState_ptr != _OpCache_with_parameter_release.end()) { + rether::_ProjectionWrite_release writeState = writeState_ptr->second; + copiedState._apply_update_for_release(writeState); + } else { copiedState.release(_tmp_2, _tmp_1); rether::_ProjectionWrite_release writeState = copiedState._update_for_release(); - std::unordered_map<rether::_ProjectionRead_release, rether::_ProjectionWrite_release, rether::_ProjectionRead_release::Hash, rether::_ProjectionRead_release::HashEqual> _OpCache_with_parameter_release; - _OpCache_with_parameter_release.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_release_lock(_ProjectionRead_release_mutex); - _OpCache_release.insert({param, _OpCache_with_parameter_release}); - } - - } else { - std::unordered_map<rether::_ProjectionRead_release, rether::_ProjectionWrite_release, rether::_ProjectionRead_release::Hash, rether::_ProjectionRead_release::HashEqual> _OpCache_with_parameter_release = _OpCache_with_parameter_release_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_release.find(readState); - if(writeState_ptr != _OpCache_with_parameter_release.end()) { - rether::_ProjectionWrite_release writeState = writeState_ptr->second; - copiedState._apply_update_for_release(writeState); - } else { - copiedState.release(_tmp_2, _tmp_1); - rether::_ProjectionWrite_release writeState = copiedState._update_for_release(); - { - std::unique_lock<std::mutex> _ProjectionRead_release_lock(_ProjectionRead_release_mutex); - _OpCache_with_parameter_release.insert({readState, writeState}); - } + _OpCache_with_parameter_release.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "release"; - result.insert(copiedState); + copiedState.stateAccessedVia = "release"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } rether::_ProjectionRead__tr_grant read__tr_grant_state = state._projected_state_for__tr_grant(); + BSet<BTuple<rether::Nodes, rether::Slots >> _trid_4; auto _trid_4_ptr = _OpCache_tr_grant.find(read__tr_grant_state); if(_trid_4_ptr == _OpCache_tr_grant.end()) { - BSet<BTuple<rether::Nodes, rether::Slots >> _trid_4 = state._tr_grant(); + _trid_4 = state._tr_grant(); { std::unique_lock<std::mutex> _ProjectionRead__tr_grant_lock(_ProjectionRead__tr_grant_mutex); _OpCache_tr_grant.insert({read__tr_grant_state, _trid_4}); } - for(const BTuple<rether::Nodes, rether::Slots >& param : _trid_4) { - rether::Slots _tmp_1 = param.projection2(); - rether::Nodes _tmp_2 = param.projection1(); - - rether copiedState = state._copy(); - rether::_ProjectionRead_grant readState = state._projected_state_for_grant(); + } else { + _trid_4 = _trid_4_ptr->second; + } - auto _OpCache_with_parameter_grant_ptr = _OpCache_grant.find(param); - if(_OpCache_with_parameter_grant_ptr == _OpCache_grant.end()) { - copiedState.grant(_tmp_2, _tmp_1); - rether::_ProjectionWrite_grant writeState = copiedState._update_for_grant(); - std::unordered_map<rether::_ProjectionRead_grant, rether::_ProjectionWrite_grant, rether::_ProjectionRead_grant::Hash, rether::_ProjectionRead_grant::HashEqual> _OpCache_with_parameter_grant; - _OpCache_with_parameter_grant.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_grant_lock(_ProjectionRead_grant_mutex); - _OpCache_grant.insert({param, _OpCache_with_parameter_grant}); - } + for(const BTuple<rether::Nodes, rether::Slots >& param : _trid_4) { + rether::Slots _tmp_1 = param.projection2(); + rether::Nodes _tmp_2 = param.projection1(); - } else { - std::unordered_map<rether::_ProjectionRead_grant, rether::_ProjectionWrite_grant, rether::_ProjectionRead_grant::Hash, rether::_ProjectionRead_grant::HashEqual> _OpCache_with_parameter_grant = _OpCache_with_parameter_grant_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_grant.find(readState); - if(writeState_ptr != _OpCache_with_parameter_grant.end()) { - rether::_ProjectionWrite_grant writeState = writeState_ptr->second; - copiedState._apply_update_for_grant(writeState); - } else { - copiedState.grant(_tmp_2, _tmp_1); - rether::_ProjectionWrite_grant writeState = copiedState._update_for_grant(); - { - std::unique_lock<std::mutex> _ProjectionRead_grant_lock(_ProjectionRead_grant_mutex); - _OpCache_with_parameter_grant.insert({readState, writeState}); - } - } + rether copiedState = state._copy(); + rether::_ProjectionRead_grant readState = state._projected_state_for_grant(); + + auto _OpCache_with_parameter_grant_ptr = _OpCache_grant.find(param); + if(_OpCache_with_parameter_grant_ptr == _OpCache_grant.end()) { + copiedState.grant(_tmp_2, _tmp_1); + rether::_ProjectionWrite_grant writeState = copiedState._update_for_grant(); + std::unordered_map<rether::_ProjectionRead_grant, rether::_ProjectionWrite_grant, rether::_ProjectionRead_grant::Hash, rether::_ProjectionRead_grant::HashEqual> _OpCache_with_parameter_grant; + _OpCache_with_parameter_grant.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_grant_lock(_ProjectionRead_grant_mutex); + _OpCache_grant.insert({param, _OpCache_with_parameter_grant}); } - copiedState.stateAccessedVia = "grant"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<BTuple<rether::Nodes, rether::Slots >> _trid_4 = _trid_4_ptr->second; - for(const BTuple<rether::Nodes, rether::Slots >& param : _trid_4) { - rether::Slots _tmp_1 = param.projection2(); - rether::Nodes _tmp_2 = param.projection1(); - - rether copiedState = state._copy(); - rether::_ProjectionRead_grant readState = state._projected_state_for_grant(); - - auto _OpCache_with_parameter_grant_ptr = _OpCache_grant.find(param); - if(_OpCache_with_parameter_grant_ptr == _OpCache_grant.end()) { + } else { + std::unordered_map<rether::_ProjectionRead_grant, rether::_ProjectionWrite_grant, rether::_ProjectionRead_grant::Hash, rether::_ProjectionRead_grant::HashEqual> _OpCache_with_parameter_grant = _OpCache_with_parameter_grant_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_grant.find(readState); + if(writeState_ptr != _OpCache_with_parameter_grant.end()) { + rether::_ProjectionWrite_grant writeState = writeState_ptr->second; + copiedState._apply_update_for_grant(writeState); + } else { copiedState.grant(_tmp_2, _tmp_1); rether::_ProjectionWrite_grant writeState = copiedState._update_for_grant(); - std::unordered_map<rether::_ProjectionRead_grant, rether::_ProjectionWrite_grant, rether::_ProjectionRead_grant::Hash, rether::_ProjectionRead_grant::HashEqual> _OpCache_with_parameter_grant; - _OpCache_with_parameter_grant.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_grant_lock(_ProjectionRead_grant_mutex); - _OpCache_grant.insert({param, _OpCache_with_parameter_grant}); - } - - } else { - std::unordered_map<rether::_ProjectionRead_grant, rether::_ProjectionWrite_grant, rether::_ProjectionRead_grant::Hash, rether::_ProjectionRead_grant::HashEqual> _OpCache_with_parameter_grant = _OpCache_with_parameter_grant_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_grant.find(readState); - if(writeState_ptr != _OpCache_with_parameter_grant.end()) { - rether::_ProjectionWrite_grant writeState = writeState_ptr->second; - copiedState._apply_update_for_grant(writeState); - } else { - copiedState.grant(_tmp_2, _tmp_1); - rether::_ProjectionWrite_grant writeState = copiedState._update_for_grant(); - { - std::unique_lock<std::mutex> _ProjectionRead_grant_lock(_ProjectionRead_grant_mutex); - _OpCache_with_parameter_grant.insert({readState, writeState}); - } + _OpCache_with_parameter_grant.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "grant"; - result.insert(copiedState); + copiedState.stateAccessedVia = "grant"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } rether::_ProjectionRead__tr_no_grant read__tr_no_grant_state = state._projected_state_for__tr_no_grant(); + BSet<BTuple<rether::Nodes, rether::Slots >> _trid_5; auto _trid_5_ptr = _OpCache_tr_no_grant.find(read__tr_no_grant_state); if(_trid_5_ptr == _OpCache_tr_no_grant.end()) { - BSet<BTuple<rether::Nodes, rether::Slots >> _trid_5 = state._tr_no_grant(); + _trid_5 = state._tr_no_grant(); { std::unique_lock<std::mutex> _ProjectionRead__tr_no_grant_lock(_ProjectionRead__tr_no_grant_mutex); _OpCache_tr_no_grant.insert({read__tr_no_grant_state, _trid_5}); } - for(const BTuple<rether::Nodes, rether::Slots >& param : _trid_5) { - rether::Slots _tmp_1 = param.projection2(); - rether::Nodes _tmp_2 = param.projection1(); - - rether copiedState = state._copy(); - rether::_ProjectionRead_no_grant readState = state._projected_state_for_no_grant(); + } else { + _trid_5 = _trid_5_ptr->second; + } - auto _OpCache_with_parameter_no_grant_ptr = _OpCache_no_grant.find(param); - if(_OpCache_with_parameter_no_grant_ptr == _OpCache_no_grant.end()) { - copiedState.no_grant(_tmp_2, _tmp_1); - rether::_ProjectionWrite_no_grant writeState = copiedState._update_for_no_grant(); - std::unordered_map<rether::_ProjectionRead_no_grant, rether::_ProjectionWrite_no_grant, rether::_ProjectionRead_no_grant::Hash, rether::_ProjectionRead_no_grant::HashEqual> _OpCache_with_parameter_no_grant; - _OpCache_with_parameter_no_grant.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_no_grant_lock(_ProjectionRead_no_grant_mutex); - _OpCache_no_grant.insert({param, _OpCache_with_parameter_no_grant}); - } + for(const BTuple<rether::Nodes, rether::Slots >& param : _trid_5) { + rether::Slots _tmp_1 = param.projection2(); + rether::Nodes _tmp_2 = param.projection1(); - } else { - std::unordered_map<rether::_ProjectionRead_no_grant, rether::_ProjectionWrite_no_grant, rether::_ProjectionRead_no_grant::Hash, rether::_ProjectionRead_no_grant::HashEqual> _OpCache_with_parameter_no_grant = _OpCache_with_parameter_no_grant_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_no_grant.find(readState); - if(writeState_ptr != _OpCache_with_parameter_no_grant.end()) { - rether::_ProjectionWrite_no_grant writeState = writeState_ptr->second; - copiedState._apply_update_for_no_grant(writeState); - } else { - copiedState.no_grant(_tmp_2, _tmp_1); - rether::_ProjectionWrite_no_grant writeState = copiedState._update_for_no_grant(); - { - std::unique_lock<std::mutex> _ProjectionRead_no_grant_lock(_ProjectionRead_no_grant_mutex); - _OpCache_with_parameter_no_grant.insert({readState, writeState}); - } - } + rether copiedState = state._copy(); + rether::_ProjectionRead_no_grant readState = state._projected_state_for_no_grant(); + + auto _OpCache_with_parameter_no_grant_ptr = _OpCache_no_grant.find(param); + if(_OpCache_with_parameter_no_grant_ptr == _OpCache_no_grant.end()) { + copiedState.no_grant(_tmp_2, _tmp_1); + rether::_ProjectionWrite_no_grant writeState = copiedState._update_for_no_grant(); + std::unordered_map<rether::_ProjectionRead_no_grant, rether::_ProjectionWrite_no_grant, rether::_ProjectionRead_no_grant::Hash, rether::_ProjectionRead_no_grant::HashEqual> _OpCache_with_parameter_no_grant; + _OpCache_with_parameter_no_grant.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_no_grant_lock(_ProjectionRead_no_grant_mutex); + _OpCache_no_grant.insert({param, _OpCache_with_parameter_no_grant}); } - copiedState.stateAccessedVia = "no_grant"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<BTuple<rether::Nodes, rether::Slots >> _trid_5 = _trid_5_ptr->second; - for(const BTuple<rether::Nodes, rether::Slots >& param : _trid_5) { - rether::Slots _tmp_1 = param.projection2(); - rether::Nodes _tmp_2 = param.projection1(); - - rether copiedState = state._copy(); - rether::_ProjectionRead_no_grant readState = state._projected_state_for_no_grant(); - - auto _OpCache_with_parameter_no_grant_ptr = _OpCache_no_grant.find(param); - if(_OpCache_with_parameter_no_grant_ptr == _OpCache_no_grant.end()) { + } else { + std::unordered_map<rether::_ProjectionRead_no_grant, rether::_ProjectionWrite_no_grant, rether::_ProjectionRead_no_grant::Hash, rether::_ProjectionRead_no_grant::HashEqual> _OpCache_with_parameter_no_grant = _OpCache_with_parameter_no_grant_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_no_grant.find(readState); + if(writeState_ptr != _OpCache_with_parameter_no_grant.end()) { + rether::_ProjectionWrite_no_grant writeState = writeState_ptr->second; + copiedState._apply_update_for_no_grant(writeState); + } else { copiedState.no_grant(_tmp_2, _tmp_1); rether::_ProjectionWrite_no_grant writeState = copiedState._update_for_no_grant(); - std::unordered_map<rether::_ProjectionRead_no_grant, rether::_ProjectionWrite_no_grant, rether::_ProjectionRead_no_grant::Hash, rether::_ProjectionRead_no_grant::HashEqual> _OpCache_with_parameter_no_grant; - _OpCache_with_parameter_no_grant.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_no_grant_lock(_ProjectionRead_no_grant_mutex); - _OpCache_no_grant.insert({param, _OpCache_with_parameter_no_grant}); - } - - } else { - std::unordered_map<rether::_ProjectionRead_no_grant, rether::_ProjectionWrite_no_grant, rether::_ProjectionRead_no_grant::Hash, rether::_ProjectionRead_no_grant::HashEqual> _OpCache_with_parameter_no_grant = _OpCache_with_parameter_no_grant_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_no_grant.find(readState); - if(writeState_ptr != _OpCache_with_parameter_no_grant.end()) { - rether::_ProjectionWrite_no_grant writeState = writeState_ptr->second; - copiedState._apply_update_for_no_grant(writeState); - } else { - copiedState.no_grant(_tmp_2, _tmp_1); - rether::_ProjectionWrite_no_grant writeState = copiedState._update_for_no_grant(); - { - std::unique_lock<std::mutex> _ProjectionRead_no_grant_lock(_ProjectionRead_no_grant_mutex); - _OpCache_with_parameter_no_grant.insert({readState, writeState}); - } + _OpCache_with_parameter_no_grant.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "no_grant"; - result.insert(copiedState); + copiedState.stateAccessedVia = "no_grant"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } rether::_ProjectionRead__tr_use_RT_Slot read__tr_use_RT_Slot_state = state._projected_state_for__tr_use_RT_Slot(); + BSet<BTuple<rether::Nodes, rether::Slots >> _trid_6; auto _trid_6_ptr = _OpCache_tr_use_RT_Slot.find(read__tr_use_RT_Slot_state); if(_trid_6_ptr == _OpCache_tr_use_RT_Slot.end()) { - BSet<BTuple<rether::Nodes, rether::Slots >> _trid_6 = state._tr_use_RT_Slot(); + _trid_6 = state._tr_use_RT_Slot(); { std::unique_lock<std::mutex> _ProjectionRead__tr_use_RT_Slot_lock(_ProjectionRead__tr_use_RT_Slot_mutex); _OpCache_tr_use_RT_Slot.insert({read__tr_use_RT_Slot_state, _trid_6}); } - for(const BTuple<rether::Nodes, rether::Slots >& param : _trid_6) { - rether::Slots _tmp_1 = param.projection2(); - rether::Nodes _tmp_2 = param.projection1(); - - rether copiedState = state._copy(); - rether::_ProjectionRead_use_RT_Slot readState = state._projected_state_for_use_RT_Slot(); + } else { + _trid_6 = _trid_6_ptr->second; + } - auto _OpCache_with_parameter_use_RT_Slot_ptr = _OpCache_use_RT_Slot.find(param); - if(_OpCache_with_parameter_use_RT_Slot_ptr == _OpCache_use_RT_Slot.end()) { - copiedState.use_RT_Slot(_tmp_2, _tmp_1); - rether::_ProjectionWrite_use_RT_Slot writeState = copiedState._update_for_use_RT_Slot(); - std::unordered_map<rether::_ProjectionRead_use_RT_Slot, rether::_ProjectionWrite_use_RT_Slot, rether::_ProjectionRead_use_RT_Slot::Hash, rether::_ProjectionRead_use_RT_Slot::HashEqual> _OpCache_with_parameter_use_RT_Slot; - _OpCache_with_parameter_use_RT_Slot.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_use_RT_Slot_lock(_ProjectionRead_use_RT_Slot_mutex); - _OpCache_use_RT_Slot.insert({param, _OpCache_with_parameter_use_RT_Slot}); - } + for(const BTuple<rether::Nodes, rether::Slots >& param : _trid_6) { + rether::Slots _tmp_1 = param.projection2(); + rether::Nodes _tmp_2 = param.projection1(); - } else { - std::unordered_map<rether::_ProjectionRead_use_RT_Slot, rether::_ProjectionWrite_use_RT_Slot, rether::_ProjectionRead_use_RT_Slot::Hash, rether::_ProjectionRead_use_RT_Slot::HashEqual> _OpCache_with_parameter_use_RT_Slot = _OpCache_with_parameter_use_RT_Slot_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_use_RT_Slot.find(readState); - if(writeState_ptr != _OpCache_with_parameter_use_RT_Slot.end()) { - rether::_ProjectionWrite_use_RT_Slot writeState = writeState_ptr->second; - copiedState._apply_update_for_use_RT_Slot(writeState); - } else { - copiedState.use_RT_Slot(_tmp_2, _tmp_1); - rether::_ProjectionWrite_use_RT_Slot writeState = copiedState._update_for_use_RT_Slot(); - { - std::unique_lock<std::mutex> _ProjectionRead_use_RT_Slot_lock(_ProjectionRead_use_RT_Slot_mutex); - _OpCache_with_parameter_use_RT_Slot.insert({readState, writeState}); - } - } + rether copiedState = state._copy(); + rether::_ProjectionRead_use_RT_Slot readState = state._projected_state_for_use_RT_Slot(); + + auto _OpCache_with_parameter_use_RT_Slot_ptr = _OpCache_use_RT_Slot.find(param); + if(_OpCache_with_parameter_use_RT_Slot_ptr == _OpCache_use_RT_Slot.end()) { + copiedState.use_RT_Slot(_tmp_2, _tmp_1); + rether::_ProjectionWrite_use_RT_Slot writeState = copiedState._update_for_use_RT_Slot(); + std::unordered_map<rether::_ProjectionRead_use_RT_Slot, rether::_ProjectionWrite_use_RT_Slot, rether::_ProjectionRead_use_RT_Slot::Hash, rether::_ProjectionRead_use_RT_Slot::HashEqual> _OpCache_with_parameter_use_RT_Slot; + _OpCache_with_parameter_use_RT_Slot.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_use_RT_Slot_lock(_ProjectionRead_use_RT_Slot_mutex); + _OpCache_use_RT_Slot.insert({param, _OpCache_with_parameter_use_RT_Slot}); } - copiedState.stateAccessedVia = "use_RT_Slot"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<BTuple<rether::Nodes, rether::Slots >> _trid_6 = _trid_6_ptr->second; - for(const BTuple<rether::Nodes, rether::Slots >& param : _trid_6) { - rether::Slots _tmp_1 = param.projection2(); - rether::Nodes _tmp_2 = param.projection1(); - - rether copiedState = state._copy(); - rether::_ProjectionRead_use_RT_Slot readState = state._projected_state_for_use_RT_Slot(); - - auto _OpCache_with_parameter_use_RT_Slot_ptr = _OpCache_use_RT_Slot.find(param); - if(_OpCache_with_parameter_use_RT_Slot_ptr == _OpCache_use_RT_Slot.end()) { + } else { + std::unordered_map<rether::_ProjectionRead_use_RT_Slot, rether::_ProjectionWrite_use_RT_Slot, rether::_ProjectionRead_use_RT_Slot::Hash, rether::_ProjectionRead_use_RT_Slot::HashEqual> _OpCache_with_parameter_use_RT_Slot = _OpCache_with_parameter_use_RT_Slot_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_use_RT_Slot.find(readState); + if(writeState_ptr != _OpCache_with_parameter_use_RT_Slot.end()) { + rether::_ProjectionWrite_use_RT_Slot writeState = writeState_ptr->second; + copiedState._apply_update_for_use_RT_Slot(writeState); + } else { copiedState.use_RT_Slot(_tmp_2, _tmp_1); rether::_ProjectionWrite_use_RT_Slot writeState = copiedState._update_for_use_RT_Slot(); - std::unordered_map<rether::_ProjectionRead_use_RT_Slot, rether::_ProjectionWrite_use_RT_Slot, rether::_ProjectionRead_use_RT_Slot::Hash, rether::_ProjectionRead_use_RT_Slot::HashEqual> _OpCache_with_parameter_use_RT_Slot; - _OpCache_with_parameter_use_RT_Slot.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_use_RT_Slot_lock(_ProjectionRead_use_RT_Slot_mutex); - _OpCache_use_RT_Slot.insert({param, _OpCache_with_parameter_use_RT_Slot}); - } - - } else { - std::unordered_map<rether::_ProjectionRead_use_RT_Slot, rether::_ProjectionWrite_use_RT_Slot, rether::_ProjectionRead_use_RT_Slot::Hash, rether::_ProjectionRead_use_RT_Slot::HashEqual> _OpCache_with_parameter_use_RT_Slot = _OpCache_with_parameter_use_RT_Slot_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_use_RT_Slot.find(readState); - if(writeState_ptr != _OpCache_with_parameter_use_RT_Slot.end()) { - rether::_ProjectionWrite_use_RT_Slot writeState = writeState_ptr->second; - copiedState._apply_update_for_use_RT_Slot(writeState); - } else { - copiedState.use_RT_Slot(_tmp_2, _tmp_1); - rether::_ProjectionWrite_use_RT_Slot writeState = copiedState._update_for_use_RT_Slot(); - { - std::unique_lock<std::mutex> _ProjectionRead_use_RT_Slot_lock(_ProjectionRead_use_RT_Slot_mutex); - _OpCache_with_parameter_use_RT_Slot.insert({readState, writeState}); - } + _OpCache_with_parameter_use_RT_Slot.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "use_RT_Slot"; - result.insert(copiedState); + copiedState.stateAccessedVia = "use_RT_Slot"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } rether::_ProjectionRead__tr_use_NRT_Slot read__tr_use_NRT_Slot_state = state._projected_state_for__tr_use_NRT_Slot(); + BSet<BTuple<rether::Nodes, rether::Slots >> _trid_7; auto _trid_7_ptr = _OpCache_tr_use_NRT_Slot.find(read__tr_use_NRT_Slot_state); if(_trid_7_ptr == _OpCache_tr_use_NRT_Slot.end()) { - BSet<BTuple<rether::Nodes, rether::Slots >> _trid_7 = state._tr_use_NRT_Slot(); + _trid_7 = state._tr_use_NRT_Slot(); { std::unique_lock<std::mutex> _ProjectionRead__tr_use_NRT_Slot_lock(_ProjectionRead__tr_use_NRT_Slot_mutex); _OpCache_tr_use_NRT_Slot.insert({read__tr_use_NRT_Slot_state, _trid_7}); } - for(const BTuple<rether::Nodes, rether::Slots >& param : _trid_7) { - rether::Slots _tmp_1 = param.projection2(); - rether::Nodes _tmp_2 = param.projection1(); - - rether copiedState = state._copy(); - rether::_ProjectionRead_use_NRT_Slot readState = state._projected_state_for_use_NRT_Slot(); + } else { + _trid_7 = _trid_7_ptr->second; + } - auto _OpCache_with_parameter_use_NRT_Slot_ptr = _OpCache_use_NRT_Slot.find(param); - if(_OpCache_with_parameter_use_NRT_Slot_ptr == _OpCache_use_NRT_Slot.end()) { - copiedState.use_NRT_Slot(_tmp_2, _tmp_1); - rether::_ProjectionWrite_use_NRT_Slot writeState = copiedState._update_for_use_NRT_Slot(); - std::unordered_map<rether::_ProjectionRead_use_NRT_Slot, rether::_ProjectionWrite_use_NRT_Slot, rether::_ProjectionRead_use_NRT_Slot::Hash, rether::_ProjectionRead_use_NRT_Slot::HashEqual> _OpCache_with_parameter_use_NRT_Slot; - _OpCache_with_parameter_use_NRT_Slot.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_use_NRT_Slot_lock(_ProjectionRead_use_NRT_Slot_mutex); - _OpCache_use_NRT_Slot.insert({param, _OpCache_with_parameter_use_NRT_Slot}); - } + for(const BTuple<rether::Nodes, rether::Slots >& param : _trid_7) { + rether::Slots _tmp_1 = param.projection2(); + rether::Nodes _tmp_2 = param.projection1(); - } else { - std::unordered_map<rether::_ProjectionRead_use_NRT_Slot, rether::_ProjectionWrite_use_NRT_Slot, rether::_ProjectionRead_use_NRT_Slot::Hash, rether::_ProjectionRead_use_NRT_Slot::HashEqual> _OpCache_with_parameter_use_NRT_Slot = _OpCache_with_parameter_use_NRT_Slot_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_use_NRT_Slot.find(readState); - if(writeState_ptr != _OpCache_with_parameter_use_NRT_Slot.end()) { - rether::_ProjectionWrite_use_NRT_Slot writeState = writeState_ptr->second; - copiedState._apply_update_for_use_NRT_Slot(writeState); - } else { - copiedState.use_NRT_Slot(_tmp_2, _tmp_1); - rether::_ProjectionWrite_use_NRT_Slot writeState = copiedState._update_for_use_NRT_Slot(); - { - std::unique_lock<std::mutex> _ProjectionRead_use_NRT_Slot_lock(_ProjectionRead_use_NRT_Slot_mutex); - _OpCache_with_parameter_use_NRT_Slot.insert({readState, writeState}); - } - } + rether copiedState = state._copy(); + rether::_ProjectionRead_use_NRT_Slot readState = state._projected_state_for_use_NRT_Slot(); + + auto _OpCache_with_parameter_use_NRT_Slot_ptr = _OpCache_use_NRT_Slot.find(param); + if(_OpCache_with_parameter_use_NRT_Slot_ptr == _OpCache_use_NRT_Slot.end()) { + copiedState.use_NRT_Slot(_tmp_2, _tmp_1); + rether::_ProjectionWrite_use_NRT_Slot writeState = copiedState._update_for_use_NRT_Slot(); + std::unordered_map<rether::_ProjectionRead_use_NRT_Slot, rether::_ProjectionWrite_use_NRT_Slot, rether::_ProjectionRead_use_NRT_Slot::Hash, rether::_ProjectionRead_use_NRT_Slot::HashEqual> _OpCache_with_parameter_use_NRT_Slot; + _OpCache_with_parameter_use_NRT_Slot.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_use_NRT_Slot_lock(_ProjectionRead_use_NRT_Slot_mutex); + _OpCache_use_NRT_Slot.insert({param, _OpCache_with_parameter_use_NRT_Slot}); } - copiedState.stateAccessedVia = "use_NRT_Slot"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<BTuple<rether::Nodes, rether::Slots >> _trid_7 = _trid_7_ptr->second; - for(const BTuple<rether::Nodes, rether::Slots >& param : _trid_7) { - rether::Slots _tmp_1 = param.projection2(); - rether::Nodes _tmp_2 = param.projection1(); - - rether copiedState = state._copy(); - rether::_ProjectionRead_use_NRT_Slot readState = state._projected_state_for_use_NRT_Slot(); - - auto _OpCache_with_parameter_use_NRT_Slot_ptr = _OpCache_use_NRT_Slot.find(param); - if(_OpCache_with_parameter_use_NRT_Slot_ptr == _OpCache_use_NRT_Slot.end()) { + } else { + std::unordered_map<rether::_ProjectionRead_use_NRT_Slot, rether::_ProjectionWrite_use_NRT_Slot, rether::_ProjectionRead_use_NRT_Slot::Hash, rether::_ProjectionRead_use_NRT_Slot::HashEqual> _OpCache_with_parameter_use_NRT_Slot = _OpCache_with_parameter_use_NRT_Slot_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_use_NRT_Slot.find(readState); + if(writeState_ptr != _OpCache_with_parameter_use_NRT_Slot.end()) { + rether::_ProjectionWrite_use_NRT_Slot writeState = writeState_ptr->second; + copiedState._apply_update_for_use_NRT_Slot(writeState); + } else { copiedState.use_NRT_Slot(_tmp_2, _tmp_1); rether::_ProjectionWrite_use_NRT_Slot writeState = copiedState._update_for_use_NRT_Slot(); - std::unordered_map<rether::_ProjectionRead_use_NRT_Slot, rether::_ProjectionWrite_use_NRT_Slot, rether::_ProjectionRead_use_NRT_Slot::Hash, rether::_ProjectionRead_use_NRT_Slot::HashEqual> _OpCache_with_parameter_use_NRT_Slot; - _OpCache_with_parameter_use_NRT_Slot.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_use_NRT_Slot_lock(_ProjectionRead_use_NRT_Slot_mutex); - _OpCache_use_NRT_Slot.insert({param, _OpCache_with_parameter_use_NRT_Slot}); - } - - } else { - std::unordered_map<rether::_ProjectionRead_use_NRT_Slot, rether::_ProjectionWrite_use_NRT_Slot, rether::_ProjectionRead_use_NRT_Slot::Hash, rether::_ProjectionRead_use_NRT_Slot::HashEqual> _OpCache_with_parameter_use_NRT_Slot = _OpCache_with_parameter_use_NRT_Slot_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_use_NRT_Slot.find(readState); - if(writeState_ptr != _OpCache_with_parameter_use_NRT_Slot.end()) { - rether::_ProjectionWrite_use_NRT_Slot writeState = writeState_ptr->second; - copiedState._apply_update_for_use_NRT_Slot(writeState); - } else { - copiedState.use_NRT_Slot(_tmp_2, _tmp_1); - rether::_ProjectionWrite_use_NRT_Slot writeState = copiedState._update_for_use_NRT_Slot(); - { - std::unique_lock<std::mutex> _ProjectionRead_use_NRT_Slot_lock(_ProjectionRead_use_NRT_Slot_mutex); - _OpCache_with_parameter_use_NRT_Slot.insert({readState, writeState}); - } + _OpCache_with_parameter_use_NRT_Slot.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "use_NRT_Slot"; - result.insert(copiedState); + copiedState.stateAccessedVia = "use_NRT_Slot"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } rether::_ProjectionRead__tr_pass_token read__tr_pass_token_state = state._projected_state_for__tr_pass_token(); + BSet<rether::Nodes> _trid_8; auto _trid_8_ptr = _OpCache_tr_pass_token.find(read__tr_pass_token_state); if(_trid_8_ptr == _OpCache_tr_pass_token.end()) { - BSet<rether::Nodes> _trid_8 = state._tr_pass_token(); + _trid_8 = state._tr_pass_token(); { std::unique_lock<std::mutex> _ProjectionRead__tr_pass_token_lock(_ProjectionRead__tr_pass_token_mutex); _OpCache_tr_pass_token.insert({read__tr_pass_token_state, _trid_8}); } - for(const rether::Nodes& param : _trid_8) { - rether::Nodes _tmp_1 = param; - - rether copiedState = state._copy(); - rether::_ProjectionRead_pass_token readState = state._projected_state_for_pass_token(); + } else { + _trid_8 = _trid_8_ptr->second; + } - auto _OpCache_with_parameter_pass_token_ptr = _OpCache_pass_token.find(param); - if(_OpCache_with_parameter_pass_token_ptr == _OpCache_pass_token.end()) { - copiedState.pass_token(_tmp_1); - rether::_ProjectionWrite_pass_token writeState = copiedState._update_for_pass_token(); - std::unordered_map<rether::_ProjectionRead_pass_token, rether::_ProjectionWrite_pass_token, rether::_ProjectionRead_pass_token::Hash, rether::_ProjectionRead_pass_token::HashEqual> _OpCache_with_parameter_pass_token; - _OpCache_with_parameter_pass_token.insert({readState, writeState}); - { - std::unique_lock<std::mutex> _ProjectionRead_pass_token_lock(_ProjectionRead_pass_token_mutex); - _OpCache_pass_token.insert({param, _OpCache_with_parameter_pass_token}); - } + for(const rether::Nodes& param : _trid_8) { + rether::Nodes _tmp_1 = param; - } else { - std::unordered_map<rether::_ProjectionRead_pass_token, rether::_ProjectionWrite_pass_token, rether::_ProjectionRead_pass_token::Hash, rether::_ProjectionRead_pass_token::HashEqual> _OpCache_with_parameter_pass_token = _OpCache_with_parameter_pass_token_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_pass_token.find(readState); - if(writeState_ptr != _OpCache_with_parameter_pass_token.end()) { - rether::_ProjectionWrite_pass_token writeState = writeState_ptr->second; - copiedState._apply_update_for_pass_token(writeState); - } else { - copiedState.pass_token(_tmp_1); - rether::_ProjectionWrite_pass_token writeState = copiedState._update_for_pass_token(); - { - std::unique_lock<std::mutex> _ProjectionRead_pass_token_lock(_ProjectionRead_pass_token_mutex); - _OpCache_with_parameter_pass_token.insert({readState, writeState}); - } - } + rether copiedState = state._copy(); + rether::_ProjectionRead_pass_token readState = state._projected_state_for_pass_token(); + + auto _OpCache_with_parameter_pass_token_ptr = _OpCache_pass_token.find(param); + if(_OpCache_with_parameter_pass_token_ptr == _OpCache_pass_token.end()) { + copiedState.pass_token(_tmp_1); + rether::_ProjectionWrite_pass_token writeState = copiedState._update_for_pass_token(); + std::unordered_map<rether::_ProjectionRead_pass_token, rether::_ProjectionWrite_pass_token, rether::_ProjectionRead_pass_token::Hash, rether::_ProjectionRead_pass_token::HashEqual> _OpCache_with_parameter_pass_token; + _OpCache_with_parameter_pass_token.insert({readState, writeState}); + { + std::unique_lock<std::mutex> _ProjectionRead_pass_token_lock(_ProjectionRead_pass_token_mutex); + _OpCache_pass_token.insert({param, _OpCache_with_parameter_pass_token}); } - copiedState.stateAccessedVia = "pass_token"; - result.insert(copiedState); - transitions += 1; - } - } else { - BSet<rether::Nodes> _trid_8 = _trid_8_ptr->second; - for(const rether::Nodes& param : _trid_8) { - rether::Nodes _tmp_1 = param; - - rether copiedState = state._copy(); - rether::_ProjectionRead_pass_token readState = state._projected_state_for_pass_token(); - - auto _OpCache_with_parameter_pass_token_ptr = _OpCache_pass_token.find(param); - if(_OpCache_with_parameter_pass_token_ptr == _OpCache_pass_token.end()) { + } else { + std::unordered_map<rether::_ProjectionRead_pass_token, rether::_ProjectionWrite_pass_token, rether::_ProjectionRead_pass_token::Hash, rether::_ProjectionRead_pass_token::HashEqual> _OpCache_with_parameter_pass_token = _OpCache_with_parameter_pass_token_ptr->second; + auto writeState_ptr = _OpCache_with_parameter_pass_token.find(readState); + if(writeState_ptr != _OpCache_with_parameter_pass_token.end()) { + rether::_ProjectionWrite_pass_token writeState = writeState_ptr->second; + copiedState._apply_update_for_pass_token(writeState); + } else { copiedState.pass_token(_tmp_1); rether::_ProjectionWrite_pass_token writeState = copiedState._update_for_pass_token(); - std::unordered_map<rether::_ProjectionRead_pass_token, rether::_ProjectionWrite_pass_token, rether::_ProjectionRead_pass_token::Hash, rether::_ProjectionRead_pass_token::HashEqual> _OpCache_with_parameter_pass_token; - _OpCache_with_parameter_pass_token.insert({readState, writeState}); { std::unique_lock<std::mutex> _ProjectionRead_pass_token_lock(_ProjectionRead_pass_token_mutex); - _OpCache_pass_token.insert({param, _OpCache_with_parameter_pass_token}); - } - - } else { - std::unordered_map<rether::_ProjectionRead_pass_token, rether::_ProjectionWrite_pass_token, rether::_ProjectionRead_pass_token::Hash, rether::_ProjectionRead_pass_token::HashEqual> _OpCache_with_parameter_pass_token = _OpCache_with_parameter_pass_token_ptr->second; - auto writeState_ptr = _OpCache_with_parameter_pass_token.find(readState); - if(writeState_ptr != _OpCache_with_parameter_pass_token.end()) { - rether::_ProjectionWrite_pass_token writeState = writeState_ptr->second; - copiedState._apply_update_for_pass_token(writeState); - } else { - copiedState.pass_token(_tmp_1); - rether::_ProjectionWrite_pass_token writeState = copiedState._update_for_pass_token(); - { - std::unique_lock<std::mutex> _ProjectionRead_pass_token_lock(_ProjectionRead_pass_token_mutex); - _OpCache_with_parameter_pass_token.insert({readState, writeState}); - } + _OpCache_with_parameter_pass_token.insert({readState, writeState}); } } + } - copiedState.stateAccessedVia = "pass_token"; - result.insert(copiedState); + copiedState.stateAccessedVia = "pass_token"; + result.insert(copiedState); + { + std::unique_lock<std::mutex> lock(mutex); transitions += 1; } } @@ -3080,7 +2825,10 @@ class ModelChecker { copiedState.elapse_time(_tmp_2, _tmp_1); copiedState.stateAccessedVia = "elapse_time"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<BTuple<rether::Nodes, rether::Slots >> _trid_2 = state._tr_reserve(); for(const BTuple<rether::Nodes, rether::Slots >& param : _trid_2) { @@ -3091,7 +2839,10 @@ class ModelChecker { copiedState.reserve(_tmp_2, _tmp_1); copiedState.stateAccessedVia = "reserve"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<BTuple<rether::Nodes, rether::Slots >> _trid_3 = state._tr_release(); for(const BTuple<rether::Nodes, rether::Slots >& param : _trid_3) { @@ -3102,7 +2853,10 @@ class ModelChecker { copiedState.release(_tmp_2, _tmp_1); copiedState.stateAccessedVia = "release"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<BTuple<rether::Nodes, rether::Slots >> _trid_4 = state._tr_grant(); for(const BTuple<rether::Nodes, rether::Slots >& param : _trid_4) { @@ -3113,7 +2867,10 @@ class ModelChecker { copiedState.grant(_tmp_2, _tmp_1); copiedState.stateAccessedVia = "grant"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<BTuple<rether::Nodes, rether::Slots >> _trid_5 = state._tr_no_grant(); for(const BTuple<rether::Nodes, rether::Slots >& param : _trid_5) { @@ -3124,7 +2881,10 @@ class ModelChecker { copiedState.no_grant(_tmp_2, _tmp_1); copiedState.stateAccessedVia = "no_grant"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<BTuple<rether::Nodes, rether::Slots >> _trid_6 = state._tr_use_RT_Slot(); for(const BTuple<rether::Nodes, rether::Slots >& param : _trid_6) { @@ -3135,7 +2895,10 @@ class ModelChecker { copiedState.use_RT_Slot(_tmp_2, _tmp_1); copiedState.stateAccessedVia = "use_RT_Slot"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<BTuple<rether::Nodes, rether::Slots >> _trid_7 = state._tr_use_NRT_Slot(); for(const BTuple<rether::Nodes, rether::Slots >& param : _trid_7) { @@ -3146,7 +2909,10 @@ class ModelChecker { copiedState.use_NRT_Slot(_tmp_2, _tmp_1); copiedState.stateAccessedVia = "use_NRT_Slot"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } BSet<rether::Nodes> _trid_8 = state._tr_pass_token(); for(const rether::Nodes& param : _trid_8) { @@ -3156,7 +2922,10 @@ class ModelChecker { copiedState.pass_token(_tmp_1); copiedState.stateAccessedVia = "pass_token"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } } diff --git a/benchmarks/model_checking_opreuse/C++/sort_m2_data1000_MC.cpp b/benchmarks/model_checking_opreuse/C++/sort_m2_data1000_MC.cpp index 2792972a9f864aeefc2ab8f33414ced598c0f20c..19178e7ab3b1c3a0254a00ecb7b1969f96e52499 100644 --- a/benchmarks/model_checking_opreuse/C++/sort_m2_data1000_MC.cpp +++ b/benchmarks/model_checking_opreuse/C++/sort_m2_data1000_MC.cpp @@ -10,7 +10,6 @@ #include <atomic> #include <any> #include <mutex> -#include <shared_mutex> #include <future> #include <boost/asio/post.hpp> #include <boost/asio/thread_pool.hpp> @@ -1540,12 +1539,16 @@ class ModelChecker { states.insert(machine); unvisitedStates.push_back(machine); - std::atomic<bool> stopThreads(false); + std::atomic<bool> stopThreads; + stopThreads = false; std::atomic<int> possibleQueueChanges; possibleQueueChanges = 0; - while(!unvisitedStates.empty() && !stopThreads.load()) { - possibleQueueChanges.fetch_add(1); + std::atomic<bool> waitFlag; + waitFlag = true; + + while(!unvisitedStates.empty() && !stopThreads) { + possibleQueueChanges += 1; sort_m2_data1000_MC state = next(); std::packaged_task<void()> task([&, state] { std::unordered_set<sort_m2_data1000_MC, sort_m2_data1000_MC::Hash, sort_m2_data1000_MC::HashEqual> nextStates = generateNextStates(state); @@ -1566,12 +1569,14 @@ class ModelChecker { } } - possibleQueueChanges.fetch_sub(1); { std::unique_lock<std::mutex> lock(mutex); - if (!unvisitedStates.empty() || possibleQueueChanges.load() == 0) { + possibleQueueChanges -= 1; + int running = possibleQueueChanges; + if (!unvisitedStates.empty() || running == 0) { { std::unique_lock<std::mutex> lock(waitMutex); + waitFlag = false; waitCV.notify_one(); } } @@ -1581,24 +1586,27 @@ class ModelChecker { if(invariantViolated(state)) { invariantViolatedBool = true; counterExampleState = state; - stopThreads.store(true); + stopThreads = true; } if(nextStates.empty()) { deadlockDetected = true; counterExampleState = state; - stopThreads.store(true); + stopThreads = true; } }); + waitFlag = true; boost::asio::post(workers, std::move(task)); { std::unique_lock<std::mutex> lock(waitMutex); - waitCV.wait(lock, [&] { - return !unvisitedStates.empty() || possibleQueueChanges == 0; - }); + if(unvisitedStates.empty() && possibleQueueChanges > 0) { + waitCV.wait(lock, [&] { + return waitFlag == false; + }); + } } } workers.join(); @@ -1687,7 +1695,10 @@ class ModelChecker { copiedState.stateAccessedVia = "progress"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } sort_m2_data1000_MC::_ProjectionRead__tr_prog1 read__tr_prog1_state = state._projected_state_for__tr_prog1(); bool _trid_2; @@ -1734,7 +1745,10 @@ class ModelChecker { copiedState.stateAccessedVia = "prog1"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } sort_m2_data1000_MC::_ProjectionRead__tr_prog2 read__tr_prog2_state = state._projected_state_for__tr_prog2(); bool _trid_3; @@ -1781,7 +1795,10 @@ class ModelChecker { copiedState.stateAccessedVia = "prog2"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } sort_m2_data1000_MC::_ProjectionRead__tr_final_evt read__tr_final_evt_state = state._projected_state_for__tr_final_evt(); bool _trid_4; @@ -1828,7 +1845,10 @@ class ModelChecker { copiedState.stateAccessedVia = "final_evt"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } } else { @@ -1837,28 +1857,40 @@ class ModelChecker { copiedState.progress(); copiedState.stateAccessedVia = "progress"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } if(state._tr_prog1()) { sort_m2_data1000_MC copiedState = state._copy(); copiedState.prog1(); copiedState.stateAccessedVia = "prog1"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } if(state._tr_prog2()) { sort_m2_data1000_MC copiedState = state._copy(); copiedState.prog2(); copiedState.stateAccessedVia = "prog2"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } if(state._tr_final_evt()) { sort_m2_data1000_MC copiedState = state._copy(); copiedState.final_evt(); copiedState.stateAccessedVia = "final_evt"; result.insert(copiedState); - transitions += 1; + { + std::unique_lock<std::mutex> lock(mutex); + transitions += 1; + } } }