void lock(my_actor* host) { host->assert_enter(); my_actor::quit_guard qg(host); bool complete = false; mutex_trig_handle ath(host); mutex_trig_notifer ntf; LAMBDA_THIS_REF4(ref4, host, complete, ath, ntf); host->send(_strand, [&ref4] { auto& lockActorID_ = ref4->_lockActorID; auto& host_ = ref4.host; if (!lockActorID_ || host_->self_id() == lockActorID_) { lockActorID_ = host_->self_id(); ref4->_recCount++; ref4.complete = true; } else { auto& ntf_ = ref4.ntf; ntf_ = ref4.ath.make_notifer(); wait_node wn = { ntf_, host_->self_id() }; ref4->_waitQueue.push_front(wn); ref4.complete = false; } }); if (!complete) { ath.wait(); } }
void lock_upgrade(my_actor* host) { host->assert_enter(); my_actor::quit_guard qg(host); bool complete = false; mutex_trig_handle ath(host); mutex_trig_notifer ntf; LAMBDA_THIS_REF4(ref4, host, complete, ath, ntf); host->send(_strand, [&ref4] { assert(ref4->_shared); assert(ref4->_inSet.find(ref4.host->self_id()) != ref4->_inSet.end()); assert(ref4->_inSet.find(ref4.host->self_id())->second); auto& inSet_ = ref4->_inSet; if (inSet_.size() == 1) { ref4.complete = true; inSet_[ref4.host->self_id()] = true; } else { auto& ntf_ = ref4.ntf; ref4.complete = false; ntf_ = ref4.ath.make_notifer(); wait_node wn = { ntf_, ref4.host->self_id(), false }; ref4->_waitQueue.push_front(wn); } }); if (!complete) { ath.wait(); } }
TUint CTupleStoreImpl::PutL(TTupleType aTupleType, const TTupleName& aTupleName, const TDesC& aSubName, const TComponentName& aComponent, const TDesC8& aSerializedData, TBBPriority aPriority, TBool aReplace, const TTime& aLeaseExpires, TBool aKeepExisting) { CALLSTACKITEM_N(_CL("CTupleStoreImpl"), _CL("PutL")); if (aTupleName.iModule.iUid == KBBAnyUidValue || aTupleName.iId == KBBAnyId || aComponent.iModule.iUid == KBBAnyUidValue || aComponent.iId == KBBAnyId) User::Leave(KErrArgument); TUint ret; { TAutomaticTransactionHolder ath(*this); TBool exists=SeekNameL(aTupleType, aTupleName, aSubName); if (exists && aKeepExisting) { UpdateL(); iTable.SetColL(ELeaseExpires, aLeaseExpires); MDBStore::PutL(); return 0; } else if (exists && aReplace) { UpdateL(); } else { InsertL(); iTable.SetColL(ETupleType, aTupleType); iTable.SetColL(ENameModule, aTupleName.iModule.iUid); iTable.SetColL(ENameId, aTupleName.iId); iTable.SetColL(ENameSubName1, aSubName); iTable.SetColL(ENameSubName2, aSubName.Left(iSubNameIndexLength)); iTable.SetColL(EPriority, aPriority); iTable.SetColL(EComponentModule, aComponent.iModule.iUid); iTable.SetColL(EComponentId, aComponent.iId); } ret=iTable.ColUint(ETupleId); if (aSerializedData.Length() > 0) { RADbColWriteStream w; w.OpenLA(iTable, EData); w.WriteUint32L(aSerializedData.Length()); w.WriteL(aSerializedData); w.CommitL(); } else { iTable.SetColNullL(EData); } iTable.SetColL(ELeaseExpires, aLeaseExpires); MDBStore::PutL(); } if (aLeaseExpires < iNextExpiry) { TTime now=GetTime(); TTimeIntervalSeconds s; aLeaseExpires.SecondsFrom(now, s); TInt wait=s.Int(); iTimer->Wait(wait); } return ret; }
bool timed_lock_upgrade(int tm, my_actor* host) { host->assert_enter(); my_actor::quit_guard qg(host); bool complete = false; mutex_trig_handle ath(host); mutex_trig_notifer ntf; msg_list<wait_node>::iterator nit; LAMBDA_THIS_REF5(ref5, host, complete, ath, ntf, nit); host->send(_strand, [&ref5] { assert(ref5->_shared); assert(ref5->_inSet.find(ref5.host->self_id()) != ref5->_inSet.end()); assert(ref5->_inSet.find(ref5.host->self_id())->second); auto& inSet_ = ref5->_inSet; if (inSet_.size() == 1) { ref5.complete = true; inSet_[ref5.host->self_id()] = true; } else { auto& ntf_ = ref5.ntf; auto& waitQueue_ = ref5->_waitQueue; ref5.complete = false; ntf_ = ref5.ath.make_notifer(); wait_node wn = { ntf_, ref5.host->self_id(), false }; waitQueue_.push_front(wn); ref5.nit = waitQueue_.begin(); } }); if (!complete) { if (!ath.timed_wait(tm)) { host->send(_strand, [&ref5] { auto& complete_ = ref5.complete; auto& notified_ = ref5.ntf._notified; complete_ = notified_; notified_ = true; if (!complete_) { ref5->_waitQueue.erase(ref5.nit); } }); if (!complete) { return false; } ath.wait(); } } return true; }
bool timed_lock(int tm, my_actor* host) { host->assert_enter(); my_actor::quit_guard qg(host); msg_list<wait_node>::iterator nit; bool complete = false; mutex_trig_handle ath(host); mutex_trig_notifer ntf; LAMBDA_THIS_REF5(ref5, host, nit, complete, ath, ntf); host->send(_strand, [&ref5] { auto& lockActorID_ = ref5->_lockActorID; auto& host_ = ref5.host; if (!lockActorID_ || host_->self_id() == lockActorID_) { lockActorID_ = host_->self_id(); ref5->_recCount++; ref5.complete = true; } else { auto& ntf_ = ref5.ntf; ntf_ = ref5.ath.make_notifer(); wait_node wn = { ntf_, host_->self_id() }; ref5->_waitQueue.push_front(wn); ref5.nit = ref5->_waitQueue.begin(); ref5.complete = false; } }); if (!complete) { if (!ath.timed_wait(tm)) { host->send(_strand, [&ref5] { auto& notified_ = ref5.ntf._notified; auto& complete_ = ref5.complete; complete_ = notified_; notified_ = true; if (!complete_) { ref5->_waitQueue.erase(ref5.nit); } }); if (!complete) { return false; } ath.wait(); } } return true; }
void wait(my_actor* host, actor_lock_guard& mutex) { host->assert_enter(); assert(mutex._host == host); my_actor::quit_guard qg(host); mutex_trig_handle ath(host); mutex_trig_notifer ntf; LAMBDA_THIS_REF2(ref2, ath, ntf); host->send(_strand, [&ref2] { ref2.ntf = ref2.ath.make_notifer(); wait_node wn = { ref2.ntf }; ref2->_waitQueue.push_back(wn); }); mutex.unlock(); ath.wait(); mutex.lock(); }
void quited_lock(my_actor* host) { assert(host->self_strand()->running_in_this_thread()); assert(_strand->running_in_this_thread()); assert(host->in_actor()); assert(host->is_quited()); host->check_stack(); if (!_lockActorID || host->self_id() == _lockActorID) { _lockActorID = host->self_id(); _recCount++; } else { mutex_trig_handle ath(host); mutex_trig_notifer ntf = ath.make_notifer(); wait_node wn = { ntf, host->self_id() }; _waitQueue.push_back(wn); ath.wait(); } }
bool timed_wait(int tm, my_actor* host, actor_lock_guard& mutex) { host->assert_enter(); assert(mutex._host == host); my_actor::quit_guard qg(host); mutex_trig_handle ath(host); mutex_trig_notifer ntf; msg_list<wait_node>::iterator nit; bool timed = false; LAMBDA_THIS_REF4(ref4, ath, nit, ntf, timed); host->send(_strand, [&ref4] { ref4.ntf = ref4.ath.make_notifer(); wait_node wn = { ref4.ntf }; ref4->_waitQueue.push_front(wn); ref4.nit = ref4->_waitQueue.begin(); }); mutex.unlock(); if (!ath.timed_wait(tm)) { host->send(_strand, [&ref4] { if (!ref4.ntf._notified) { ref4.timed = true; ref4->_waitQueue.erase(ref4.nit); } }); if (!timed) { ath.wait(); } } mutex.lock(); return !timed; }