bool Thread::interrupted() { ThreadHandle handle = currentThread(); if(!handle.is_null()) { return handle->consumeInterruptionSync(); } else { return false; } };
void AddThr::run() { Functions::DemuxersInfo demuxersInfo; for (Module *module : QMPlay2Core.getPluginsInstance()) for (const Module::Info &mod : module->getModulesInfo()) if (mod.type == Module::DEMUXER) demuxersInfo += {mod.name, mod.icon.isNull() ? module->icon() : mod.icon, mod.extensions}; add(urls, par, demuxersInfo, existingEntries.isEmpty() ? nullptr : &existingEntries, loadList); if (currentThread() == pLW.thread()) //jeżeli funkcja działa w głównym wątku finished(); }
void SQLTransactionBackend::notifyDatabaseThreadIsShuttingDown() { ASSERT(currentThread() == database()->databaseContext()->databaseThread()->getThreadID()); // If the transaction is in progress, we should roll it back here, since this // is our last opportunity to do something related to this transaction on the // DB thread. Amongst other work, doCleanup() will clear m_sqliteTransaction // which invokes SQLiteTransaction's destructor, which will do the roll back // if necessary. doCleanup(); }
void initializeThreading() { if (!atomicallyInitializedStaticMutex) { atomicallyInitializedStaticMutex = new Mutex; threadMapMutex(); wtf_random_init(); initializeMainThread(); mainThreadIdentifier = currentThread(); setThreadName(mainThreadIdentifier, "Main Thread"); } }
RefPtr<DOMStringList> IDBObjectStore::indexNames() const { ASSERT(currentThread() == m_transaction->database().originThreadID()); RefPtr<DOMStringList> indexNames = DOMStringList::create(); for (auto& name : m_info.indexNames()) indexNames->append(name); indexNames->sort(); return indexNames; }
void TimerBase::start(double nextFireInterval, double repeatInterval, const WebTraceLocation& caller) { #if DCHECK_IS_ON() DCHECK_EQ(m_thread, currentThread()); #endif m_location = caller; m_repeatInterval = repeatInterval; setNextFireTime(timerMonotonicallyIncreasingTime(), nextFireInterval); }
bool OfflineAudioDestinationHandler::renderIfNotSuspended(AudioBus* sourceBus, AudioBus* destinationBus, size_t numberOfFrames) { // We don't want denormals slowing down any of the audio processing // since they can very seriously hurt performance. // This will take care of all AudioNodes because they all process within this scope. DenormalDisabler denormalDisabler; context()->deferredTaskHandler().setAudioThread(currentThread()); if (!context()->isDestinationInitialized()) { destinationBus->zero(); return false; } // Take care pre-render tasks at the beginning of each render quantum. Then // it will stop the rendering loop if the context needs to be suspended // at the beginning of the next render quantum. if (context()->handlePreOfflineRenderTasks()) { suspendOfflineRendering(); return true; } // Prepare the local audio input provider for this render quantum. if (sourceBus) m_localAudioInputProvider.set(sourceBus); ASSERT(numberOfInputs() >= 1); if (numberOfInputs() < 1) { destinationBus->zero(); return false; } // This will cause the node(s) connected to us to process, which in turn will pull on their input(s), // all the way backwards through the rendering graph. AudioBus* renderedBus = input(0).pull(destinationBus, numberOfFrames); if (!renderedBus) { destinationBus->zero(); } else if (renderedBus != destinationBus) { // in-place processing was not possible - so copy destinationBus->copyFrom(*renderedBus); } // Process nodes which need a little extra help because they are not connected to anything, but still need to process. context()->deferredTaskHandler().processAutomaticPullNodes(numberOfFrames); // Let the context take care of any business at the end of each render quantum. context()->handlePostOfflineRenderTasks(); // Advance current sample-frame. size_t newSampleFrame = m_currentSampleFrame + numberOfFrames; releaseStore(&m_currentSampleFrame, newSampleFrame); return false; }
TimerBase::TimerBase() : m_nextFireTime(0) , m_unalignedNextFireTime(0) , m_repeatInterval(0) , m_heapIndex(-1) , m_cachedThreadGlobalTimerHeap(0) #if ENABLE(ASSERT) , m_thread(currentThread()) #endif { }
void IDBOpenDBRequest::onSuccess(const IDBResultData& resultData) { LOG(IndexedDB, "IDBOpenDBRequest::onSuccess()"); ASSERT(currentThread() == originThreadID()); setResult(IDBDatabase::create(*scriptExecutionContext(), connectionProxy(), resultData)); m_isDone = true; enqueueEvent(IDBRequestCompletionEvent::create(eventNames().successEvent, false, false, *this)); }
bool IDBOpenDBRequest::dispatchEvent(Event& event) { ASSERT(currentThread() == originThreadID()); bool result = IDBRequest::dispatchEvent(event); if (m_transaction && m_transaction->isVersionChange() && (event.type() == eventNames().errorEvent || event.type() == eventNames().successEvent)) m_transaction->database().connectionProxy().didFinishHandlingVersionChangeTransaction(m_transaction->database().databaseConnectionIdentifier(), *m_transaction); return result; }
void TimerBase::stop() { ASSERT(m_thread == currentThread()); m_repeatInterval = 0; setNextFireTime(0); ASSERT(m_nextFireTime == 0); ASSERT(m_repeatInterval == 0); ASSERT(!inHeap()); }
ThreadState::ThreadState(intptr_t* startOfStack) : m_thread(currentThread()) , m_startOfStack(startOfStack) { ASSERT(!**s_threadSpecific); **s_threadSpecific = this; // FIXME: This is to silence clang that complains about unused private // member. Remove once we implement stack scanning that uses it. (void) m_startOfStack; }
void IDBDatabase::didCommitTransaction(IDBTransaction& transaction) { LOG(IndexedDB, "IDBDatabase::didCommitTransaction %s", transaction.info().identifier().loggingString().utf8().data()); ASSERT(currentThread() == originThreadID()); if (m_versionChangeTransaction == &transaction) m_info.setVersion(transaction.info().newVersion()); didCommitOrAbortTransaction(transaction); }
WorkerMessagingProxy::WorkerMessagingProxy(Worker* workerObject) : m_scriptExecutionContext(workerObject->scriptExecutionContext()) , m_workerObject(workerObject) , m_unconfirmedMessageCount(0) , m_workerThreadHadPendingActivity(false) , m_askedToTerminate(false) { ASSERT(m_workerObject); ASSERT((m_scriptExecutionContext->isDocument() && isMainThread()) || (m_scriptExecutionContext->isWorkerContext() && currentThread() == static_cast<WorkerContext*>(m_scriptExecutionContext.get())->thread()->threadID())); }
void IDBDatabase::renameIndex(IDBIndex& index, const String& newName) { ASSERT(currentThread() == originThreadID()); ASSERT(m_versionChangeTransaction); ASSERT(m_info.hasObjectStore(index.objectStore().info().name())); ASSERT(m_info.infoForExistingObjectStore(index.objectStore().info().name())->hasIndex(index.info().name())); m_info.infoForExistingObjectStore(index.objectStore().info().name())->infoForExistingIndex(index.info().identifier())->rename(newName); m_versionChangeTransaction->renameIndex(index, newName); }
void TimerBase::stop() { ASSERT(m_thread == currentThread() || (isMainThread() || pthread_main_np()) && WebCoreWebThreadIsLockedOrDisabled()); m_repeatInterval = 0; setNextFireTime(0); ASSERT(m_nextFireTime == 0); ASSERT(m_repeatInterval == 0); ASSERT(!inHeap()); }
TimerBase::TimerBase() : m_nextFireTime(0) , m_unalignedNextFireTime(0) , m_repeatInterval(0) , m_heapIndex(-1) , m_cachedThreadGlobalTimerHeap(0) #ifndef NDEBUG , m_thread(currentThread()) , m_wasDeleted(false) #endif { }
bool IDBDatabase::hasPendingActivity() const { ASSERT(currentThread() == originThreadID() || mayBeGCThread()); if (m_closedInServer) return false; if (!m_activeTransactions.isEmpty() || !m_committingTransactions.isEmpty() || !m_abortingTransactions.isEmpty()) return true; return hasEventListeners(m_eventNames.abortEvent) || hasEventListeners(m_eventNames.errorEvent) || hasEventListeners(m_eventNames.versionchangeEvent); }
bool IDBDatabase::dispatchEvent(Event& event) { LOG(IndexedDB, "IDBDatabase::dispatchEvent (%" PRIu64 ") (%p)", m_databaseConnectionIdentifier, this); ASSERT(currentThread() == originThreadID()); bool result = EventTargetWithInlineData::dispatchEvent(event); if (event.isVersionChangeEvent() && event.type() == m_eventNames.versionchangeEvent) connectionProxy().didFireVersionChangeEvent(m_databaseConnectionIdentifier, downcast<IDBVersionChangeEvent>(event).requestIdentifier()); return result; }
void endParallel() { __sync_fetch_and_add(&gActiveThreadCount, -1); while (gActiveThreadCount > 0) ; if (currentThread() == 0) { // Stop all but me *((unsigned int*) 0xffff0064) = ~1; } }
void IDBDatabase::didStartTransaction(IDBTransaction& transaction) { LOG(IndexedDB, "IDBDatabase::didStartTransaction %s", transaction.info().identifier().loggingString().utf8().data()); ASSERT(!m_versionChangeTransaction); ASSERT(currentThread() == originThreadID()); // It is possible for the client to have aborted a transaction before the server replies back that it has started. if (m_abortingTransactions.contains(transaction.info().identifier())) return; m_activeTransactions.set(transaction.info().identifier(), &transaction); }
void initializeMainThread(void (*function)(MainThreadFunction, void*)) { static bool initializedMainThread; if (initializedMainThread) return; initializedMainThread = true; callOnMainThreadFunction = function; mainThreadIdentifier = currentThread(); AtomicString::init(); }
void initializeThreading() { if (!atomicallyInitializedStaticMutex) { atomicallyInitializedStaticMutex = new Mutex; threadMapMutex(); initializeRandomNumberGenerator(); #if !PLATFORM(DARWIN) || PLATFORM(CHROMIUM) mainThreadIdentifier = currentThread(); #endif initializeMainThread(); } }
void initializeMainThread() { static bool initializedMainThread; if (initializedMainThread) return; initializedMainThread = true; mainThreadIdentifier = currentThread(); initializeMainThreadPlatform(); initializeGCThreads(); }
NEVER_INLINE void LockBase::lockSlow() { unsigned spinCount = 0; // This magic number turns out to be optimal based on past JikesRVM experiments. const unsigned spinLimit = 40; for (;;) { uint8_t currentByteValue = m_byte.load(); if (verbose) dataLog(toString(currentThread(), ": locking with ", currentByteValue, "\n")); // We allow ourselves to barge in. if (!(currentByteValue & isHeldBit) && m_byte.compareExchangeWeak(currentByteValue, currentByteValue | isHeldBit)) return; // If there is nobody parked and we haven't spun too much, we can just try to spin around. if (!(currentByteValue & hasParkedBit) && spinCount < spinLimit) { spinCount++; std::this_thread::yield(); continue; } // Need to park. We do this by setting the parked bit first, and then parking. We spin around // if the parked bit wasn't set and we failed at setting it. if (!(currentByteValue & hasParkedBit) && !m_byte.compareExchangeWeak(currentByteValue, currentByteValue | hasParkedBit)) continue; // We now expect the value to be isHeld|hasParked. So long as that's the case, we can park. ParkingLot::ParkResult parkResult = ParkingLot::compareAndPark(&m_byte, isHeldBit | hasParkedBit); if (parkResult.wasUnparked) { switch (static_cast<Token>(parkResult.token)) { case DirectHandoff: // The lock was never released. It was handed to us directly by the thread that did // unlock(). This means we're done! RELEASE_ASSERT(isHeld()); return; case BargingOpportunity: // This is the common case. The thread that called unlock() has released the lock, // and we have been woken up so that we may get an opportunity to grab the lock. But // other threads may barge, so the best that we can do is loop around and try again. break; } } // We have awoken, or we never parked because the byte value changed. Either way, we loop // around and try again. } }
RefPtr<WebCore::IDBTransaction> IDBDatabase::transaction(const Vector<String>& objectStores, const String& modeString, ExceptionCodeWithMessage& ec) { LOG(IndexedDB, "IDBDatabase::transaction"); ASSERT(currentThread() == originThreadID()); if (m_closePending) { ec.code = IDBDatabaseException::InvalidStateError; ec.message = ASCIILiteral("Failed to execute 'transaction' on 'IDBDatabase': The database connection is closing."); return nullptr; } if (objectStores.isEmpty()) { ec.code = IDBDatabaseException::InvalidAccessError; ec.message = ASCIILiteral("Failed to execute 'transaction' on 'IDBDatabase': The storeNames parameter was empty."); return nullptr; } IndexedDB::TransactionMode mode = IDBTransaction::stringToMode(modeString, ec.code); if (ec.code) { ec.message = makeString(ASCIILiteral("Failed to execute 'transaction' on 'IDBDatabase': The mode provided ('"), modeString, ASCIILiteral("') is not one of 'readonly' or 'readwrite'.")); return nullptr; } if (mode != IndexedDB::TransactionMode::ReadOnly && mode != IndexedDB::TransactionMode::ReadWrite) { ec.code = TypeError; return nullptr; } if (m_versionChangeTransaction && !m_versionChangeTransaction->isFinishedOrFinishing()) { ec.code = IDBDatabaseException::InvalidStateError; ec.message = ASCIILiteral("Failed to execute 'transaction' on 'IDBDatabase': A version change transaction is running."); return nullptr; } for (auto& objectStoreName : objectStores) { if (m_info.hasObjectStore(objectStoreName)) continue; ec.code = IDBDatabaseException::NotFoundError; ec.message = ASCIILiteral("Failed to execute 'transaction' on 'IDBDatabase': One of the specified object stores was not found."); return nullptr; } auto info = IDBTransactionInfo::clientTransaction(m_connectionProxy.get(), objectStores, mode); auto transaction = IDBTransaction::create(*this, info); LOG(IndexedDB, "IDBDatabase::transaction - Added active transaction %s", info.identifier().loggingString().utf8().data()); m_activeTransactions.set(info.identifier(), &transaction.get()); return adoptRef(&transaction.leakRef()); }
void AudioDestinationNode::render(AudioBus*, AudioBus* destinationBus, size_t numberOfFrames) { // We don't want denormals slowing down any of the audio processing // since they can very seriously hurt performance. // This will take care of all AudioNodes because they all process within this scope. DenormalDisabler denormalDisabler; context().setAudioThread(currentThread()); if (!context().isInitialized()) { destinationBus->zero(); setIsSilent(true); return; } ASSERT(numberOfFrames); if (!numberOfFrames) { destinationBus->zero(); setIsSilent(true); return; } // Let the context take care of any business at the start of each render quantum. context().handlePreRenderTasks(); // This will cause the node(s) connected to us to process, which in turn will pull on their input(s), // all the way backwards through the rendering graph. AudioBus* renderedBus = input(0)->pull(destinationBus, numberOfFrames); if (!renderedBus) destinationBus->zero(); else if (renderedBus != destinationBus) { // in-place processing was not possible - so copy destinationBus->copyFrom(*renderedBus); } // Process nodes which need a little extra help because they are not connected to anything, but still need to process. context().processAutomaticPullNodes(numberOfFrames); // Let the context take care of any business at the end of each render quantum. context().handlePostRenderTasks(); // Advance current sample-frame. m_currentSampleFrame += numberOfFrames; setIsSilent(destinationBus->isSilent()); // The reason we are handling mute after the call to setIsSilent() is because the muted state does // not affect the audio destination node's effective playing state. if (m_muted) destinationBus->zero(); }
ExceptionOr<Ref<IDBRequest>> IDBIndex::getAllKeys(ExecState& execState, RefPtr<IDBKeyRange> range, Optional<uint32_t> count) { LOG(IndexedDB, "IDBIndex::getAllKeys"); ASSERT(currentThread() == m_objectStore.transaction().database().originThreadID()); if (m_deleted || m_objectStore.isDeleted()) return Exception { IDBDatabaseException::InvalidStateError, ASCIILiteral("Failed to execute 'getAllKeys' on 'IDBIndex': The index or its object store has been deleted.") }; if (!m_objectStore.transaction().isActive()) return Exception { IDBDatabaseException::TransactionInactiveError, ASCIILiteral("Failed to execute 'getAllKeys' on 'IDBIndex': The transaction is inactive or finished.") }; return m_objectStore.transaction().requestGetAllIndexRecords(execState, *this, range.get(), IndexedDB::GetAllType::Keys, count); }
WorkerContext::~WorkerContext() { ASSERT(currentThread() == thread()->threadID()); #if ENABLE(NOTIFICATIONS) m_notifications.clear(); #endif // Make sure we have no observers. notifyObserversOfStop(); // Notify proxy that we are going away. This can free the WorkerThread object, so do not access it after this. thread()->workerReportingProxy().workerContextDestroyed(); }
void WorkerRunLoop::runCleanupTasks(WorkerGlobalScope* context) { ASSERT(context); ASSERT(context->thread().threadID() == currentThread()); ASSERT(m_messageQueue.killed()); while (true) { auto task = m_messageQueue.tryGetMessageIgnoringKilled(); if (!task) return; task->performTask(*this, context); } }