void alert_manager::maybe_notify(alert* a, std::unique_lock<std::mutex>& lock) { if (m_alerts[m_generation].size() == 1) { lock.unlock(); // we just posted to an empty queue. If anyone is waiting for // alerts, we need to notify them. Also (potentially) call the // user supplied m_notify callback to let the client wake up its // message loop to poll for alerts. if (m_notify) m_notify(); // TODO: 2 keep a count of the number of threads waiting. Only if it's // > 0 notify them m_condition.notify_all(); } else { lock.unlock(); } #ifndef TORRENT_DISABLE_EXTENSIONS for (auto& e : m_ses_extensions) e->on_alert(a); #else TORRENT_UNUSED(a); #endif }
CS_StatusValue UsbCameraImpl::DeviceCmdSetMode( std::unique_lock<wpi::mutex>& lock, const Message& msg) { VideoMode newMode; if (msg.kind == Message::kCmdSetMode) { newMode.pixelFormat = msg.data[0]; newMode.width = msg.data[1]; newMode.height = msg.data[2]; newMode.fps = msg.data[3]; m_modeSetPixelFormat = true; m_modeSetResolution = true; m_modeSetFPS = true; } else if (msg.kind == Message::kCmdSetPixelFormat) { newMode = m_mode; newMode.pixelFormat = msg.data[0]; m_modeSetPixelFormat = true; } else if (msg.kind == Message::kCmdSetResolution) { newMode = m_mode; newMode.width = msg.data[0]; newMode.height = msg.data[1]; m_modeSetResolution = true; } else if (msg.kind == Message::kCmdSetFPS) { newMode = m_mode; newMode.fps = msg.data[0]; m_modeSetFPS = true; } // If the pixel format or resolution changed, we need to disconnect and // reconnect if (newMode.pixelFormat != m_mode.pixelFormat || newMode.width != m_mode.width || newMode.height != m_mode.height) { m_mode = newMode; lock.unlock(); bool wasStreaming = m_streaming; if (wasStreaming) DeviceStreamOff(); if (m_fd >= 0) { DeviceDisconnect(); DeviceConnect(); } if (wasStreaming) DeviceStreamOn(); Notifier::GetInstance().NotifySourceVideoMode(*this, newMode); lock.lock(); } else if (newMode.fps != m_mode.fps) { m_mode = newMode; lock.unlock(); // Need to stop streaming to set FPS bool wasStreaming = m_streaming; if (wasStreaming) DeviceStreamOff(); DeviceSetFPS(); if (wasStreaming) DeviceStreamOn(); Notifier::GetInstance().NotifySourceVideoMode(*this, newMode); lock.lock(); } return CS_OK; }
void F::stop_client (std::unique_lock <std::mutex> &lock) { bool wasLocked; if (lock) { wasLocked = true; } if (!wasLocked) { lock.lock(); } if (client) { client->stop(); } terminate = true; lock.unlock(); GST_DEBUG ("Waiting for client thread to finish"); clientThread.join(); if (wasLocked) { lock.lock(); } }
void handle_reconnect(std::unique_lock<std::mutex>& lock, SyncSession& session) const override { // Ask the binding to retry getting the token for this session. std::shared_ptr<SyncSession> session_ptr = session.shared_from_this(); lock.unlock(); session.m_config.bind_session_handler(session_ptr->m_realm_path, session_ptr->m_config, session_ptr); }
channel_op_status push_and_notify_( ptr_t new_node, std::unique_lock< mutex > & lk) noexcept { push_tail_( new_node); lk.unlock(); not_empty_cond_.notify_one(); return channel_op_status::success; }
void Heap::deallocateXLarge(std::unique_lock<StaticMutex>& lock, void* object) { Range toDeallocate = m_xLargeObjects.pop(&findXLarge(lock, object)); lock.unlock(); vmDeallocate(toDeallocate.begin(), toDeallocate.size()); lock.lock(); }
bool access_token_expired(std::unique_lock<std::mutex>& lock, SyncSession& session) const override { session.advance_state(lock, waiting_for_access_token); std::shared_ptr<SyncSession> session_ptr = session.shared_from_this(); lock.unlock(); session.m_config.bind_session_handler(session_ptr->m_realm_path, session_ptr->m_config, session_ptr); return false; }
void SyncSession::unregister(std::unique_lock<std::mutex>& lock) { REALM_ASSERT(lock.owns_lock()); REALM_ASSERT(m_state == &State::inactive); // Must stop an active session before unregistering. lock.unlock(); SyncManager::shared().unregister_session(m_realm_path); }
void PageInfo::finishRelease(std::unique_lock<std::mutex> lock) { delete[] p_buffer; lock.unlock(); p_cache->p_cacheHost->afterRelease(this); lock.lock(); if(p_waitQueue.empty()) { auto iterator = p_cache->p_presentPages.find(p_number); assert(iterator != p_cache->p_presentPages.end()); p_cache->p_presentPages.erase(iterator); delete this; }else{ lock.unlock(); p_cache->p_cacheHost->requestAcquire(this); } }
// helper for releasing connection and placing it in pool inline void pushConnection( std::unique_lock<std::mutex> &locker, ConPool &pool, redisConnection* con ) { pool.second.push(con); locker.unlock(); // notify other threads for their wake up in case of they are waiting // about empty connection queue pool.first.notify_one(); }
static inline void sleep(std::unique_lock<StaticMutex>& lock, std::chrono::milliseconds duration) { if (duration == std::chrono::milliseconds(0)) return; lock.unlock(); std::this_thread::sleep_for(duration); lock.lock(); }
void RepeatedTimerTask::schedule(std::unique_lock<raft_mutex_t>& lck) { _next_duetime = butil::milliseconds_from_now(adjust_timeout_ms(_timeout_ms)); if (bthread_timer_add(&_timer, _next_duetime, on_timedout, this) != 0) { lck.unlock(); LOG(ERROR) << "Fail to add timer"; return on_timedout(this); } }
void SingleTaskScheduler::resume(std::unique_lock<Spinlock> lock) { assert(task_->status == Suspended || task_->status == Listening); assert(!task_->scheduled); task_->status = Running; task_->scheduled = false; task_->resumes += 1; resumed.store(true, std::memory_order_release); lock.unlock(); }
bool Listener::FindNextEventInternal( std::unique_lock<std::mutex> &lock, Broadcaster *broadcaster, // nullptr for any broadcaster const ConstString *broadcaster_names, // nullptr for any event uint32_t num_broadcaster_names, uint32_t event_type_mask, EventSP &event_sp, bool remove) { // NOTE: callers of this function must lock m_events_mutex using a // Mutex::Locker // and pass the locker as the first argument. m_events_mutex is no longer // recursive. Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EVENTS)); if (m_events.empty()) return false; Listener::event_collection::iterator pos = m_events.end(); if (broadcaster == nullptr && broadcaster_names == nullptr && event_type_mask == 0) { pos = m_events.begin(); } else { pos = std::find_if(m_events.begin(), m_events.end(), EventMatcher(broadcaster, broadcaster_names, num_broadcaster_names, event_type_mask)); } if (pos != m_events.end()) { event_sp = *pos; if (log != nullptr) log->Printf("%p '%s' Listener::FindNextEventInternal(broadcaster=%p, " "broadcaster_names=%p[%u], event_type_mask=0x%8.8x, " "remove=%i) event %p", static_cast<void *>(this), GetName(), static_cast<void *>(broadcaster), static_cast<const void *>(broadcaster_names), num_broadcaster_names, event_type_mask, remove, static_cast<void *>(event_sp.get())); if (remove) { m_events.erase(pos); // Unlock the event queue here. We've removed this event and are about to // return // it so it should be okay to get the next event off the queue here - and // it might // be useful to do that in the "DoOnRemoval". lock.unlock(); event_sp->DoOnRemoval(); } return true; } event_sp.reset(); return false; }
int HttpMessage::UnlockAndFlushToBodyReader(std::unique_lock<butil::Mutex>& mu) { if (_body.empty()) { mu.unlock(); return 0; } butil::IOBuf body_seen = _body.movable(); ProgressiveReader* r = _body_reader; mu.unlock(); for (size_t i = 0; i < body_seen.backing_block_num(); ++i) { butil::StringPiece blk = body_seen.backing_block(i); butil::Status st = r->OnReadOnePart(blk.data(), blk.size()); if (!st.ok()) { mu.lock(); _body_reader = NULL; mu.unlock(); r->OnEndOfMessage(st); return -1; } } return 0; }
void WorkQueue::runItemWithoutLock(std::unique_lock<std::mutex> &lock) { Item item = std::move(item_heap.front()); std::pop_heap(std::begin(item_heap), std::end(item_heap)); item_heap.pop_back(); idle_flag = false; lock.unlock(); item.func(); lock.lock(); idle_flag = true; cond.notify_all(); }
// checks to see if we're no longer exceeding the high watermark, // and if we're in fact below the low watermark. If so, we need to // post the notification messages to the peers that are waiting for // more buffers to received data into void disk_buffer_pool::check_buffer_level(std::unique_lock<std::mutex>& l) { TORRENT_ASSERT(l.owns_lock()); if (!m_exceeded_max_size || m_in_use > m_low_watermark) return; m_exceeded_max_size = false; std::vector<std::weak_ptr<disk_observer>> cbs; m_observers.swap(cbs); l.unlock(); m_ios.post(std::bind(&watermark_callback, std::move(cbs))); }
TetrisGame_impl(IRenderFunc *cb_):cb(cb_), timeCount(0), mField(),current(I,lockdelay,&mField), ghost(I,lockdelay,&mField),inputBuffer(), re(),pieces(shift_right,hard_drop), isPaused(true),isContinuing(false), pauseMutex(),cbMutex(), pauseLock(pauseMutex), pauseCondition(), runner() { pauseLock.unlock(); inputBuffer.reserve(minBuffer); }
bool UsbCameraProperty::DeviceSet(std::unique_lock<wpi::mutex>& lock, IAMVideoProcAmp* pProcAmp, int newValue) const { if (!pProcAmp) return true; lock.unlock(); if (SUCCEEDED( pProcAmp->Set(tagVideoProc, newValue, VideoProcAmp_Flags_Manual))) { lock.lock(); return true; } return false; }
bool UsbCameraProperty::DeviceGet(std::unique_lock<wpi::mutex>& lock, IAMVideoProcAmp* pProcAmp) { if (!pProcAmp) return true; lock.unlock(); long newValue = 0, paramFlag = 0; // NOLINT(runtime/int) if (SUCCEEDED(pProcAmp->Get(tagVideoProc, &newValue, ¶mFlag))) { lock.lock(); value = newValue; return true; } return false; }
void file_pool::remove_oldest(std::unique_lock<std::mutex>& l) { file_set::iterator i = std::min_element(m_files.begin(), m_files.end() , boost::bind(&lru_file_entry::last_use, boost::bind(&file_set::value_type::second, _1)) < boost::bind(&lru_file_entry::last_use, boost::bind(&file_set::value_type::second, _2))); if (i == m_files.end()) return; file_handle file_ptr = i->second.file_ptr; m_files.erase(i); // closing a file may be long running operation (mac os x) l.unlock(); file_ptr.reset(); l.lock(); }
void file_pool::remove_oldest(std::unique_lock<std::mutex>& l) { using value_type = decltype(m_files)::value_type; auto const i = std::min_element(m_files.begin(), m_files.end() , [] (value_type const& lhs, value_type const& rhs) { return lhs.second.last_use < rhs.second.last_use; }); if (i == m_files.end()) return; file_handle file_ptr = i->second.file_ptr; m_files.erase(i); // closing a file may be long running operation (mac os x) l.unlock(); file_ptr.reset(); l.lock(); }
bool StatefulWriter::try_remove_change(std::chrono::microseconds& microseconds, std::unique_lock<std::recursive_mutex>& lock) { logInfo(RTPS_WRITER, "Starting process try remove change for writer " << getGuid()); SequenceNumber_t min_low_mark; for(auto it = matched_readers.begin(); it != matched_readers.end(); ++it) { std::lock_guard<std::recursive_mutex> rguard(*(*it)->mp_mutex); if(min_low_mark == SequenceNumber_t() || (*it)->get_low_mark() < min_low_mark) { min_low_mark = (*it)->get_low_mark(); } } SequenceNumber_t calc = min_low_mark < get_seq_num_min() ? SequenceNumber_t() : (min_low_mark - get_seq_num_min()) + 1; unsigned int may_remove_change = 1; if(calc <= SequenceNumber_t()) { lock.unlock(); std::unique_lock<std::mutex> may_lock(may_remove_change_mutex_); may_remove_change_ = 0; may_remove_change_cond_.wait_for(may_lock, microseconds, [&]() { return may_remove_change_ > 0; }); may_remove_change = may_remove_change_; may_lock.unlock(); lock.lock(); } // Some changes acked if(may_remove_change == 1) { return mp_history->remove_min_change(); } // Waiting a change was removed. else if(may_remove_change == 2) { return true; } return false; }
void natpmp::disable(error_code const& ec, std::unique_lock<std::mutex>& l) { m_disabled = true; for (std::vector<mapping_t>::iterator i = m_mappings.begin() , end(m_mappings.end()); i != end; ++i) { if (i->protocol == none) continue; int const proto = i->protocol; i->protocol = none; int index = i - m_mappings.begin(); l.unlock(); m_callback(index, address(), 0, proto, ec); l.lock(); } close_impl(l); }
void CacheHost::releaseItem(Cacheable *item, std::unique_lock<std::mutex> &lock) { assert(lock.owns_lock()); assert(item != &p_sentinel); item->p_alive = false; p_activeFootprint -= item->getFootprint(); // remove the item from the list Cacheable *less_recently = item->p_lessRecentlyUsed; Cacheable *more_recently = item->p_moreRecentlyUsed; less_recently->p_moreRecentlyUsed = more_recently; more_recently->p_lessRecentlyUsed = less_recently; lock.unlock(); item->release(); lock.lock(); }
void NetworkInterfaceImplBoost::run(std::unique_lock<std::mutex>& lock) { try { if (m_acceptor.is_open()) { lock.unlock(); m_ioService.run(); } } catch (const std::exception& e) { logger.error("NetworkInterfaceImplBoost::run() caught: ", e.what()); } catch (...) { logger.error("NetworkInterfaceImplBoost::run() caught error"); } }
void MultiTaskScheduler::resume(Task* task, std::unique_lock<Spinlock> lock) { assert(lock.owns_lock()); assert(task->status == Starting || task->status == Listening || task->status == Suspended); assert(!task->scheduled); TaskStatus status = task->status; task->resumes += 1; task->scheduled = true; lock.unlock(); if (status == Starting || status == Listening) { std::unique_lock<Spinlock> lock(softMutex); softTasks.push_front(task); } else if (status == Suspended) { std::unique_lock<Spinlock> lock(hardMutex); hardTasks.push_front(task); } else { // Impossible. __builtin_unreachable(); } }
void natpmp::log(char const* msg, std::unique_lock<std::mutex>& l) { l.unlock(); m_log_callback(msg); l.lock(); }
void FunctionScheduler::runOneFunction(std::unique_lock<std::mutex>& lock, steady_clock::time_point now) { DCHECK(lock.mutex() == &mutex_); DCHECK(lock.owns_lock()); // The function to run will be at the end of functions_ already. // // Fully remove it from functions_ now. // We need to release mutex_ while we invoke this function, and we need to // maintain the heap property on functions_ while mutex_ is unlocked. RepeatFunc func(std::move(functions_.back())); functions_.pop_back(); if (!func.cb) { VLOG(5) << func.name << "function has been canceled while waiting"; return; } currentFunction_ = &func; // Update the function's next run time. if (steady_) { // This allows scheduler to catch up func.setNextRunTimeSteady(); } else { // Note that we set nextRunTime based on the current time where we started // the function call, rather than the time when the function finishes. // This ensures that we call the function once every time interval, as // opposed to waiting time interval seconds between calls. (These can be // different if the function takes a significant amount of time to run.) func.setNextRunTimeStrict(now); } // Release the lock while we invoke the user's function lock.unlock(); // Invoke the function try { VLOG(5) << "Now running " << func.name; func.cb(); } catch (const std::exception& ex) { LOG(ERROR) << "Error running the scheduled function <" << func.name << ">: " << exceptionStr(ex); } // Re-acquire the lock lock.lock(); if (!currentFunction_) { // The function was cancelled while we were running it. // We shouldn't reschedule it; return; } // Clear currentFunction_ CHECK_EQ(currentFunction_, &func); currentFunction_ = nullptr; // Re-insert the function into our functions_ heap. // We only maintain the heap property while running_ is set. (running_ may // have been cleared while we were invoking the user's function.) functions_.push_back(std::move(func)); if (running_) { std::push_heap(functions_.begin(), functions_.end(), fnCmp_); } }
void close_( std::unique_lock< mutex > & lk) noexcept { state_ = queue_status::closed; lk.unlock(); not_empty_cond_.notify_all(); }