Lines Matching defs:node
33 void AddNode(FutexWaitListNode* node);
34 void RemoveNode(FutexWaitListNode* node);
41 // Deletes "node" and returns the next node of its list.
42 static FutexWaitListNode* DeleteAsyncWaiterNode(FutexWaitListNode* node) {
43 DCHECK_NOT_NULL(node->isolate_for_async_waiters_);
44 auto next = node->next_;
45 if (node->prev_ != nullptr) {
46 node->prev_->next_ = next;
49 next->prev_ = node->prev_;
51 delete node;
60 auto node = *head;
61 while (node != nullptr) {
62 if (node->isolate_for_async_waiters_ == isolate) {
63 node->timeout_task_id_ = CancelableTaskManager::kInvalidTaskId;
64 node = DeleteAsyncWaiterNode(node);
67 new_head = node;
69 new_tail = node;
70 node = node->next_;
79 // Verifies the local consistency of |node|. If it's the first node of its
80 // list, it must be |head|, and if it's the last node, it must be |tail|.
81 void VerifyNode(FutexWaitListNode* node, FutexWaitListNode* head,
83 // Returns true if |node| is on the linked list starting with |head|.
84 static bool NodeIsOnList(FutexWaitListNode* node, FutexWaitListNode* head);
105 // and `interrupted_` fields for each individual list node that is currently
157 FutexWaitListNode* node)
158 : CancelableTask(cancelable_task_manager), node_(node) {}
168 void FutexEmulation::NotifyAsyncWaiter(FutexWaitListNode* node) {
175 node->async_timeout_time_ = base::TimeTicks();
177 g_wait_list.Pointer()->RemoveNode(node);
181 // timeout task will just ignore the node.
183 auto it = isolate_map.find(node->isolate_for_async_waiters_);
186 isolate_map.insert(std::make_pair(node->isolate_for_async_waiters_,
187 FutexWaitList::HeadAndTail{node, node}));
189 node->cancelable_task_manager_, node->isolate_for_async_waiters_);
190 node->task_runner_->PostNonNestableTask(std::move(task));
193 node->prev_ = it->second.tail;
194 it->second.tail->next_ = node;
195 it->second.tail = node;
199 void FutexWaitList::AddNode(FutexWaitListNode* node) {
200 DCHECK_NULL(node->prev_);
201 DCHECK_NULL(node->next_);
202 auto it = location_lists_.find(node->wait_location_);
205 std::make_pair(node->wait_location_, HeadAndTail{node, node}));
207 it->second.tail->next_ = node;
208 node->prev_ = it->second.tail;
209 it->second.tail = node;
215 void FutexWaitList::RemoveNode(FutexWaitListNode* node) {
216 auto it = location_lists_.find(node->wait_location_);
218 DCHECK(NodeIsOnList(node, it->second.head));
220 if (node->prev_) {
221 node->prev_->next_ = node->next_;
223 DCHECK_EQ(node, it->second.head);
224 it->second.head = node->next_;
227 if (node->next_) {
228 node->next_->prev_ = node->prev_;
230 DCHECK_EQ(node, it->second.tail);
231 it->second.tail = node->prev_;
234 // If the node was the last one on its list, delete the whole list.
235 if (node->prev_ == nullptr && node->next_ == nullptr) {
239 node->prev_ = node->next_ = nullptr;
389 FutexWaitListNode* node = isolate->futex_wait_list_node();
390 node->backing_store_ = backing_store;
391 node->wait_addr_ = addr;
394 node->wait_location_ = wait_location;
395 node->waiting_ = true;
397 // Reset node->waiting_ = false when leaving this scope (but while
399 FutexWaitListNode::ResetWaitingOnScopeExit reset_waiting(node);
424 g_wait_list.Pointer()->AddNode(node);
427 bool interrupted = node->interrupted_;
428 node->interrupted_ = false;
444 // notification will wake up the condition variable. node->waiting() will
458 if (node->interrupted_) {
464 node->waiting_ = false;
468 if (!node->waiting_) {
485 node->cond_.WaitFor(g_mutex.Pointer(), time_until_timeout);
488 node->cond_.Wait(g_mutex.Pointer());
494 g_wait_list.Pointer()->RemoveNode(node);
570 FutexWaitListNode* node = new FutexWaitListNode(
574 node->async_timeout_time_ = base::TimeTicks::Now() + rel_timeout;
576 node->cancelable_task_manager_, node);
577 node->timeout_task_id_ = task->id();
578 node->task_runner_->PostNonNestableDelayedTask(
582 g_wait_list.Pointer()->AddNode(node);
669 FutexWaitListNode* node = it->second.head;
670 while (node && num_waiters_to_wake > 0) {
673 node->backing_store_.lock();
675 if (!node->waiting_) {
676 node = node->next_;
680 // against the case where the BackingStore of the node has been deleted and
683 DCHECK_EQ(addr, node->wait_addr_);
684 node->waiting_ = false;
686 // Retrieve the next node to iterate before calling NotifyAsyncWaiter,
687 // since NotifyAsyncWaiter will take the node out of the linked list.
688 auto old_node = node;
689 node = node->next_;
693 // WaitSync will remove the node from the list.
703 if (node->async_timeout_time_ == base::TimeTicks()) {
704 // Backing store has been deleted and the node is still waiting, and
712 DCHECK(node->IsAsync());
713 DCHECK_EQ(CancelableTaskManager::kInvalidTaskId, node->timeout_task_id_);
716 if (node->IsAsync() && node->native_context_.IsEmpty()) {
723 if (node->CancelTimeoutTask()) {
727 // running and will clean up the node.
731 auto old_node = node;
732 node = node->next_;
738 node = node->next_;
745 void FutexEmulation::CleanupAsyncWaiterPromise(FutexWaitListNode* node) {
746 // This function must run in the main thread of node's Isolate. This function
749 DCHECK(node->IsAsync());
751 Isolate* isolate = node->isolate_for_async_waiters_;
754 if (!node->promise_.IsEmpty()) {
756 Utils::OpenHandle(*node->promise_.Get(v8_isolate)));
758 DCHECK(!node->native_context_.IsEmpty());
760 Utils::OpenHandle(*node->native_context_.Get(v8_isolate)));
773 DCHECK(node->native_context_.IsEmpty());
777 void FutexEmulation::ResolveAsyncWaiterPromise(FutexWaitListNode* node) {
778 // This function must run in the main thread of node's Isolate.
781 reinterpret_cast<v8::Isolate*>(node->isolate_for_async_waiters_);
790 bool success = node->CancelTimeoutTask();
794 if (!node->promise_.IsEmpty()) {
795 DCHECK(!node->native_context_.IsEmpty());
796 Local<v8::Context> native_context = node->native_context_.Get(v8_isolate);
799 Utils::OpenHandle(*node->promise_.Get(v8_isolate)));
803 if (node->async_timeout_time_ != base::TimeTicks()) {
804 DCHECK(node->waiting_);
806 node->isolate_for_async_waiters_->factory()->timed_out_string();
808 DCHECK(!node->waiting_);
809 result_string = node->isolate_for_async_waiters_->factory()->ok_string();
821 FutexWaitListNode* node;
829 node = it->second.head;
833 // The list of nodes starting from "node" are no longer on any list, so it's
838 while (node) {
839 DCHECK_EQ(isolate, node->isolate_for_async_waiters_);
840 DCHECK(!node->waiting_);
841 ResolveAsyncWaiterPromise(node);
842 CleanupAsyncWaiterPromise(node);
843 // We've already tried to cancel the timeout task for the node; since we're
845 // timeout task will never happen, and it's safe to delete the node here.
846 DCHECK_EQ(CancelableTaskManager::kInvalidTaskId, node->timeout_task_id_);
847 node = FutexWaitList::DeleteAsyncWaiterNode(node);
851 void FutexEmulation::HandleAsyncWaiterTimeout(FutexWaitListNode* node) {
852 // This function must run in the main thread of node's Isolate.
853 DCHECK(node->IsAsync());
858 node->timeout_task_id_ = CancelableTaskManager::kInvalidTaskId;
859 if (!node->waiting_) {
864 g_wait_list.Pointer()->RemoveNode(node);
867 // "node" has been taken out of the lists, so it's ok to access it without
870 HandleScope handle_scope(node->isolate_for_async_waiters_);
871 ResolveAsyncWaiterPromise(node);
872 CleanupAsyncWaiterPromise(node);
873 delete node;
904 auto node = it->second.head;
905 while (node) {
906 DCHECK_EQ(isolate, node->isolate_for_async_waiters_);
907 node->timeout_task_id_ = CancelableTaskManager::kInvalidTaskId;
908 node = FutexWaitList::DeleteAsyncWaiterNode(node);
931 FutexWaitListNode* node = it->second.head;
932 while (node != nullptr) {
934 node->backing_store_.lock();
935 if (backing_store.get() == node_backing_store.get() && node->waiting_) {
939 node = node->next_;
950 FutexWaitListNode* node = it.second.head;
951 while (node != nullptr) {
952 if (node->isolate_for_async_waiters_ == isolate && node->waiting_) {
955 node = node->next_;
972 FutexWaitListNode* node = it.second.head;
973 while (node != nullptr) {
975 node->backing_store_.lock();
977 addr == node->wait_addr_ && !node->waiting_) {
981 node = node->next_;
988 void FutexWaitList::VerifyNode(FutexWaitListNode* node, FutexWaitListNode* head,
991 if (node->next_ != nullptr) {
992 DCHECK_NE(node, tail);
993 DCHECK_EQ(node, node->next_->prev_);
995 DCHECK_EQ(node, tail);
997 if (node->prev_ != nullptr) {
998 DCHECK_NE(node, head);
999 DCHECK_EQ(node, node->prev_->next_);
1001 DCHECK_EQ(node, head);
1004 if (node->async_timeout_time_ != base::TimeTicks()) {
1005 DCHECK(node->IsAsync());
1008 DCHECK(NodeIsOnList(node, head));
1015 FutexWaitListNode* node = it.second.head;
1016 while (node != nullptr) {
1017 VerifyNode(node, it.second.head, it.second.tail);
1018 node = node->next_;
1023 auto node = it.second.head;
1024 while (node != nullptr) {
1025 VerifyNode(node, it.second.head, it.second.tail);
1026 DCHECK_EQ(it.first, node->isolate_for_async_waiters_);
1027 node = node->next_;
1033 bool FutexWaitList::NodeIsOnList(FutexWaitListNode* node,
1037 if (n == node) {