#include <message_handler.h>

Inheritance diagram for dart::MessageHandler:

Classes
class	AcquiredQueues

Public Types
enum	MessageStatus { kOK , kError , kShutdown }

typedef uword	CallbackData

typedef MessageStatus(*	StartCallback) (CallbackData data)

typedef void(*	EndCallback) (CallbackData data)

Public Member Functions
virtual	~MessageHandler ()

virtual const char *	name () const

bool	Run (ThreadPool *pool, StartCallback start_callback, EndCallback end_callback, CallbackData data)

MessageStatus	HandleNextMessage ()

MessageStatus	HandleOOBMessages ()

MessageStatus	PauseAndHandleAllMessages (int64_t timeout_millis)

bool	HasOOBMessages ()

bool	HasMessages ()

virtual bool	KeepAliveLocked ()

void	RequestDeletion ()

bool	paused () const

void	increment_paused ()

void	decrement_paused ()

void	DebugDump ()

bool	should_pause_on_start () const

void	set_should_pause_on_start (bool should_pause_on_start)

bool	is_paused_on_start () const

bool	should_pause_on_exit () const

void	set_should_pause_on_exit (bool should_pause_on_exit)

bool	is_paused_on_exit () const

int64_t	paused_timestamp () const

bool	ShouldPauseOnStart (MessageStatus status) const

bool	ShouldPauseOnExit (MessageStatus status) const

void	PausedOnStart (bool paused)

void	PausedOnExit (bool paused)

Static Public Member Functions
static const char *	MessageStatusString (MessageStatus status)

Protected Member Functions
	MessageHandler ()

virtual bool	IsCurrentIsolate () const

virtual Isolate *	isolate () const

void	PostMessage (std::unique_ptr< Message > message, bool before_events=false)

void	ClosePort (Dart_Port port)

void	CloseAllPorts ()

virtual void	MessageNotify (Message::Priority priority)

virtual MessageStatus	HandleMessage (std::unique_ptr< Message > message)=0

virtual void	NotifyPauseOnStart ()

virtual void	NotifyPauseOnExit ()

Thread *	thread () const

Friends
class	PortMap

class	MessageHandlerTestPeer

class	MessageHandlerTask

template<typename GCVisitorType >
void	MournFinalizerEntry (GCVisitorType *, FinalizerEntryPtr)

Detailed Description

Definition at line 20 of file message_handler.h.

Member Typedef Documentation

◆ CallbackData

typedef uword dart::MessageHandler::CallbackData

Definition at line 37 of file message_handler.h.

◆ EndCallback

typedef void(* dart::MessageHandler::EndCallback) (CallbackData data)

Definition at line 39 of file message_handler.h.

◆ StartCallback

typedef MessageStatus(* dart::MessageHandler::StartCallback) (CallbackData data)

Definition at line 38 of file message_handler.h.

Member Enumeration Documentation

◆ MessageStatus

enum dart::MessageHandler::MessageStatus

Enumerator
kOK
kError
kShutdown

Definition at line 25 of file message_handler.h.

                     {
    kOK,        // We successfully handled a message.
    kError,     // We encountered an error handling a message.
    kShutdown,  // The VM is shutting down.
  };

Constructor & Destructor Documentation

◆ MessageHandler()

dart::MessageHandler::MessageHandler ( )

protected

Definition at line 55 of file message_handler.cc.

    : queue_(new MessageQueue()),
      oob_queue_(new MessageQueue()),
      oob_message_handling_allowed_(true),
      paused_for_messages_(false),
      paused_(0),
#if !defined(PRODUCT)
      should_pause_on_start_(false),
      should_pause_on_exit_(false),
      is_paused_on_start_(false),
      is_paused_on_exit_(false),
      remembered_paused_on_exit_status_(kOK),
      paused_timestamp_(-1),
#endif
      task_running_(false),
      delete_me_(false),
      pool_(nullptr),
      start_callback_(nullptr),
      end_callback_(nullptr),
      callback_data_(0) {
  ASSERT(queue_ != nullptr);
  ASSERT(oob_queue_ != nullptr);
}

◆ ~MessageHandler()

dart::MessageHandler::~MessageHandler ( )

virtual

Definition at line 79 of file message_handler.cc.

                                {
  delete queue_;
  delete oob_queue_;
  queue_ = nullptr;
  oob_queue_ = nullptr;
  pool_ = nullptr;
}

Member Function Documentation

◆ CloseAllPorts()

void dart::MessageHandler::CloseAllPorts ( )

protected

Definition at line 543 of file message_handler.cc.

                                   {
  MonitorLocker ml(&monitor_);
  if (FLAG_trace_isolates) {
    OS::PrintErr(
        "[-] Closing all ports:\n"
        "\thandler:    %s\n",
        name());
  }
  queue_->Clear();
  oob_queue_->Clear();
}

◆ ClosePort()

void dart::MessageHandler::ClosePort ( Dart_Port port )

protected

Definition at line 532 of file message_handler.cc.

                                             {
  if (FLAG_trace_isolates) {
    MonitorLocker ml(&monitor_);
    OS::PrintErr(
        "[-] Closing port:\n"
        "\thandler:    %s\n"
        "\tport:       %" Pd64 "\n",
        name(), port);
  }
}

◆ DebugDump()

void dart::MessageHandler::DebugDump ( )

Definition at line 570 of file message_handler.cc.

                               {
  PortMap::DebugDumpForMessageHandler(this);
}

◆ decrement_paused()

void dart::MessageHandler::decrement_paused ( )

inline

Definition at line 101 of file message_handler.h.

                          {
    ASSERT(paused_ > 0);
    paused_--;
  }

◆ HandleMessage()

virtual MessageStatus dart::MessageHandler::HandleMessage ( std::unique_ptr< Message > message )

protectedpure virtual

Implemented in dart::SendAndExitMessagesHandler, dart::IsolateMessageHandler, dart::TestMessageHandler, dart::NativeMessageHandler, dart::PortTestMessageHandler, dart::ServiceTestMessageHandler, and dart::FakeMessageHandler.

◆ HandleNextMessage()

MessageHandler::MessageStatus dart::MessageHandler::HandleNextMessage ( )

Definition at line 290 of file message_handler.cc.

                                                              {
  // We can only call HandleNextMessage when this handler is not
  // assigned to a thread pool.
  MonitorLocker ml(&monitor_);
  ASSERT(pool_ == nullptr);
  ASSERT(!delete_me_);
#if defined(DEBUG)
  CheckAccess();
#endif
  return HandleMessages(&ml, true, false);
}

◆ HandleOOBMessages()

MessageHandler::MessageStatus dart::MessageHandler::HandleOOBMessages ( )

Definition at line 338 of file message_handler.cc.

                                                              {
  if (!oob_message_handling_allowed_) {
    return kOK;
  }
  MonitorLocker ml(&monitor_);
  ASSERT(!delete_me_);
#if defined(DEBUG)
  CheckAccess();
#endif
  return HandleMessages(&ml, false, false);
}

◆ HasMessages()

bool dart::MessageHandler::HasMessages ( )

Definition at line 385 of file message_handler.cc.

                                 {
  MonitorLocker ml(&monitor_);
  return !queue_->IsEmpty();
}

◆ HasOOBMessages()

bool dart::MessageHandler::HasOOBMessages ( )

Definition at line 372 of file message_handler.cc.

                                    {
  MonitorLocker ml(&monitor_);
  return !oob_queue_->IsEmpty();
}

◆ increment_paused()

void dart::MessageHandler::increment_paused ( )

inline

Definition at line 100 of file message_handler.h.

100{ paused_++; }

◆ is_paused_on_exit()

bool dart::MessageHandler::is_paused_on_exit ( ) const

inline

Definition at line 123 of file message_handler.h.

123{ return is_paused_on_exit_; }

◆ is_paused_on_start()

bool dart::MessageHandler::is_paused_on_start ( ) const

inline

Definition at line 115 of file message_handler.h.

115{ return is_paused_on_start_; }

◆ IsCurrentIsolate()

virtual bool dart::MessageHandler::IsCurrentIsolate ( ) const

inlineprotectedvirtual

Reimplemented in dart::IsolateMessageHandler.

Definition at line 178 of file message_handler.h.

178{ return false; }

◆ isolate()

virtual Isolate * dart::MessageHandler::isolate ( ) const

inlineprotectedvirtual

Reimplemented in dart::SendAndExitMessagesHandler, dart::IsolateMessageHandler, and dart::ServiceTestMessageHandler.

Definition at line 181 of file message_handler.h.

181{ return nullptr; }

◆ KeepAliveLocked()

virtual bool dart::MessageHandler::KeepAliveLocked ( )

inlinevirtual

Reimplemented in dart::IsolateMessageHandler.

Definition at line 88 of file message_handler.h.

                                 {
    // By default we keep alive until the message handler was asked to shutdown
    // via [RequestDeletion].
    return !delete_me_;
  }

◆ MessageNotify()

void dart::MessageHandler::MessageNotify ( Message::Priority priority )

protectedvirtual

Reimplemented in dart::IsolateMessageHandler, dart::TestMessageHandler, and dart::PortTestMessageHandler.

Definition at line 97 of file message_handler.cc.

                                                           {
  // By default, there is no custom message notification.
}

◆ MessageStatusString()

const char * dart::MessageHandler::MessageStatusString ( MessageStatus status )

static

Definition at line 41 of file message_handler.cc.

                                                                    {
  switch (status) {
    case kOK:
      return "OK";
    case kError:
      return "Error";
    case kShutdown:
      return "Shutdown";
    default:
      UNREACHABLE();
      return "Illegal";
  }
}

◆ name()

const char * dart::MessageHandler::name ( ) const

virtual

Reimplemented in dart::SendAndExitMessagesHandler, dart::IsolateMessageHandler, and dart::NativeMessageHandler.

Definition at line 87 of file message_handler.cc.

                                       {
  return "<unnamed>";
}

◆ NotifyPauseOnExit()

virtual void dart::MessageHandler::NotifyPauseOnExit ( )

inlineprotectedvirtual

Reimplemented in dart::IsolateMessageHandler.

Definition at line 206 of file message_handler.h.

206{}

◆ NotifyPauseOnStart()

virtual void dart::MessageHandler::NotifyPauseOnStart ( )

inlineprotectedvirtual

Reimplemented in dart::IsolateMessageHandler.

Definition at line 205 of file message_handler.h.

205{}

◆ PauseAndHandleAllMessages()

MessageHandler::MessageStatus dart::MessageHandler::PauseAndHandleAllMessages ( int64_t timeout_millis )

Definition at line 302 of file message_handler.cc.

                            {
  MonitorLocker ml(&monitor_, /*no_safepoint_scope=*/false);
  ASSERT(task_running_);
  ASSERT(!delete_me_);
#if defined(DEBUG)
  CheckAccess();
#endif
  paused_for_messages_ = true;
  while (queue_->IsEmpty() && oob_queue_->IsEmpty()) {
    Monitor::WaitResult wr;
    {
      // Ensure this thread is at a safepoint while we wait for new messages to
      // arrive.
      TransitionVMToNative transition(Thread::Current());
      wr = ml.Wait(timeout_millis);
    }
    ASSERT(task_running_);
    ASSERT(!delete_me_);
    if (wr == Monitor::kTimedOut) {
      break;
    }
    if (queue_->IsEmpty()) {
      // There are only OOB messages. Handle them and then continue waiting for
      // normal messages unless there is an error.
      MessageStatus status = HandleMessages(&ml, false, false);
      if (status != kOK) {
        paused_for_messages_ = false;
        return status;
      }
    }
  }
  paused_for_messages_ = false;
  return HandleMessages(&ml, true, true);
}

◆ paused()

bool dart::MessageHandler::paused ( ) const

inline

Definition at line 98 of file message_handler.h.

98{ return paused_ > 0; }

◆ paused_timestamp()

int64_t dart::MessageHandler::paused_timestamp ( ) const

inline

Definition at line 126 of file message_handler.h.

126{ return paused_timestamp_; }

◆ PausedOnExit()

void dart::MessageHandler::PausedOnExit ( bool paused )

Definition at line 605 of file message_handler.cc.

                                             {
  MonitorLocker ml(&monitor_);
  PausedOnExitLocked(&ml, paused);
}

◆ PausedOnStart()

void dart::MessageHandler::PausedOnStart ( bool paused )

Definition at line 574 of file message_handler.cc.

                                              {
  MonitorLocker ml(&monitor_);
  PausedOnStartLocked(&ml, paused);
}

◆ PostMessage()

void dart::MessageHandler::PostMessage	(	std::unique_ptr< Message >	message,
		bool	before_events = `false`
	)

protected

Definition at line 130 of file message_handler.cc.

                                                     {
  Message::Priority saved_priority;
 
  {
    MonitorLocker ml(&monitor_);
    if (FLAG_trace_isolates) {
      Isolate* source_isolate = Isolate::Current();
      if (source_isolate != nullptr) {
        OS::PrintErr(
            "[>] Posting message:\n"
            "\tlen:        %" Pd "\n\tsource:     (%" Pd64
            ") %s\n\tdest:       %s\n"
            "\tdest_port:  %" Pd64 "\n",
            message->Size(), static_cast<int64_t>(source_isolate->main_port()),
            source_isolate->name(), name(), message->dest_port());
      } else {
        OS::PrintErr(
            "[>] Posting message:\n"
            "\tlen:        %" Pd
            "\n\tsource:     <native code>\n"
            "\tdest:       %s\n"
            "\tdest_port:  %" Pd64 "\n",
            message->Size(), name(), message->dest_port());
      }
    }
 
    saved_priority = message->priority();
    if (message->IsOOB()) {
      oob_queue_->Enqueue(std::move(message), before_events);
    } else {
      queue_->Enqueue(std::move(message), before_events);
    }
    if (paused_for_messages_) {
      ml.Notify();
    }
 
    if (pool_ != nullptr && !task_running_) {
      ASSERT(!delete_me_);
      task_running_ = true;
      const bool launched_successfully = pool_->Run<MessageHandlerTask>(this);
      ASSERT(launched_successfully);
    }
  }
 
  // Invoke any custom message notification.
  MessageNotify(saved_priority);
}

◆ RequestDeletion()

void dart::MessageHandler::RequestDeletion ( )

Definition at line 555 of file message_handler.cc.

                                     {
  {
    MonitorLocker ml(&monitor_);
    if (task_running_) {
      // This message handler currently has a task running on the thread pool.
      delete_me_ = true;
      return;
    }
  }
 
  // This message handler has no current task.  Delete it.
  delete this;
}

◆ Run()

bool dart::MessageHandler::Run	(	ThreadPool *	pool,
		StartCallback	start_callback,
		EndCallback	end_callback,
		CallbackData	data
	)

Definition at line 101 of file message_handler.cc.

                                            {
  MonitorLocker ml(&monitor_);
  if (FLAG_trace_isolates) {
    OS::PrintErr(
        "[+] Starting message handler:\n"
        "\thandler:    %s\n",
        name());
  }
  ASSERT(pool_ == nullptr);
  ASSERT(!delete_me_);
  pool_ = pool;
  start_callback_ = start_callback;
  end_callback_ = end_callback;
  callback_data_ = data;
  task_running_ = true;
  bool result = pool_->Run<MessageHandlerTask>(this);
  if (!result) {
    pool_ = nullptr;
    start_callback_ = nullptr;
    end_callback_ = nullptr;
    callback_data_ = 0;
    task_running_ = false;
  }
  return result;
}

◆ set_should_pause_on_exit()

void dart::MessageHandler::set_should_pause_on_exit ( bool should_pause_on_exit )

inline

Definition at line 119 of file message_handler.h.

                                                           {
    should_pause_on_exit_ = should_pause_on_exit;
  }

◆ set_should_pause_on_start()

void dart::MessageHandler::set_should_pause_on_start ( bool should_pause_on_start )

inline

Definition at line 111 of file message_handler.h.

                                                             {
    should_pause_on_start_ = should_pause_on_start;
  }

◆ should_pause_on_exit()

bool dart::MessageHandler::should_pause_on_exit ( ) const

inline

Definition at line 117 of file message_handler.h.

117{ return should_pause_on_exit_; }

◆ should_pause_on_start()

bool dart::MessageHandler::should_pause_on_start ( ) const

inline

Definition at line 109 of file message_handler.h.

109{ return should_pause_on_start_; }

◆ ShouldPauseOnExit()

bool dart::MessageHandler::ShouldPauseOnExit ( MessageStatus status ) const

Definition at line 362 of file message_handler.cc.

                                                                 {
  Isolate* owning_isolate = isolate();
  if (owning_isolate == nullptr) {
    return false;
  }
  return (status != MessageHandler::kShutdown) && should_pause_on_exit() &&
         owning_isolate->is_runnable();
}

◆ ShouldPauseOnStart()

bool dart::MessageHandler::ShouldPauseOnStart ( MessageStatus status ) const

Definition at line 351 of file message_handler.cc.

                                                                  {
  Isolate* owning_isolate = isolate();
  if (owning_isolate == nullptr) {
    return false;
  }
  // If we are restarting or shutting down, we do not want to honor
  // should_pause_on_start or should_pause_on_exit.
  return (status != MessageHandler::kShutdown) && should_pause_on_start() &&
         owning_isolate->is_runnable();
}

◆ thread()

Thread * dart::MessageHandler::thread ( ) const

inlineprotected

Definition at line 209 of file message_handler.h.

209{ return Thread::Current(); }

Friends And Related Symbol Documentation

◆ MessageHandlerTask

friend class MessageHandlerTask

friend

Definition at line 216 of file message_handler.h.

◆ MessageHandlerTestPeer

friend class MessageHandlerTestPeer

friend

Definition at line 215 of file message_handler.h.

◆ MournFinalizerEntry

template<typename GCVisitorType >

void MournFinalizerEntry	(	GCVisitorType *	visitor,
		FinalizerEntryPtr	current_entry
	)

friend

Definition at line 162 of file gc_shared.h.

                                                          {
  TRACE_FINALIZER("Processing Entry %p", current_entry->untag());
 
  const Heap::Space before_gc_space = SpaceForExternal(current_entry);
  const bool value_collected_this_gc =
      GCVisitorType::ForwardOrSetNullIfCollected(
          current_entry, &current_entry->untag()->value_);
  if (!value_collected_this_gc && before_gc_space == Heap::kNew) {
    const Heap::Space after_gc_space = SpaceForExternal(current_entry);
    if (after_gc_space == Heap::kOld) {
      const intptr_t external_size = current_entry->untag()->external_size_;
      TRACE_FINALIZER("Promoting external size %" Pd
                      " bytes from new to old space",
                      external_size);
      visitor->isolate_group()->heap()->PromotedExternal(external_size);
    }
  }
  GCVisitorType::ForwardOrSetNullIfCollected(current_entry,
                                             &current_entry->untag()->detach_);
  GCVisitorType::ForwardOrSetNullIfCollected(
      current_entry, &current_entry->untag()->finalizer_);
 
  ObjectPtr token_object = current_entry->untag()->token();
  // See sdk/lib/_internal/vm/lib/internal_patch.dart FinalizerBase.detach.
  const bool is_detached = token_object == current_entry;
 
  if (!value_collected_this_gc) return;
  if (is_detached) return;
 
  FinalizerBasePtr finalizer = current_entry->untag()->finalizer();
 
  if (finalizer.IsRawNull()) {
    TRACE_FINALIZER("Value collected entry %p finalizer null",
                    current_entry->untag());
 
    // Do nothing, the finalizer has been GCed.
    return;
  }
 
  TRACE_FINALIZER("Value collected entry %p finalizer %p",
                  current_entry->untag(), finalizer->untag());
 
  FinalizerPtr finalizer_dart = static_cast<FinalizerPtr>(finalizer);
  // Move entry to entries collected and current head of that list as
  // the next element. Using a atomic exchange satisfies concurrency
  // between the parallel GC tasks.
  // We rely on the fact that the mutator thread is not running to avoid
  // races between GC and mutator modifying Finalizer.entries_collected.
  //
  // We only run in serial marker or in the finalize step in the marker,
  // both are in safepoint.
  // The main scavenger worker is at safepoint, the other scavenger
  // workers are not, but they bypass safepoint because the main
  // worker is at a safepoint already.
  ASSERT(Thread::Current()->OwnsGCSafepoint() ||
         Thread::Current()->BypassSafepoints());
 
  if (finalizer.IsNativeFinalizer()) {
    NativeFinalizerPtr native_finalizer =
        static_cast<NativeFinalizerPtr>(finalizer);
 
    // Immediately call native callback.
    RunNativeFinalizerCallback(native_finalizer, current_entry, before_gc_space,
                               visitor);
 
    // Fall-through sending a message to clear the entries and remove
    // from detachments.
  }
 
  FinalizerEntryPtr previous_head =
      finalizer_dart->untag()->exchange_entries_collected(current_entry);
  current_entry->untag()->set_next(previous_head);
  const bool first_entry = previous_head.IsRawNull();
 
  // If we're in the marker, we need to ensure that we release the store
  // buffer afterwards.
  // If we're in the scavenger and have the finalizer in old space and
  // a new space entry, we don't need to release the store buffer.
  if (!first_entry && previous_head->IsNewObject() &&
      current_entry->IsOldObject()) {
    TRACE_FINALIZER("Entry %p (old) next is %p (new)", current_entry->untag(),
                    previous_head->untag());
    // We must release the thread's store buffer block.
  }
 
  // Schedule calling Dart finalizer.
  if (first_entry) {
    Isolate* isolate = finalizer->untag()->isolate_;
    if (isolate == nullptr) {
      TRACE_FINALIZER("Not scheduling finalizer %p callback on isolate null",
                      finalizer->untag());
    } else {
      TRACE_FINALIZER("Scheduling finalizer %p callback on isolate %p",
                      finalizer->untag(), isolate);
 
      PersistentHandle* handle =
          isolate->group()->api_state()->AllocatePersistentHandle();
      handle->set_ptr(finalizer);
      MessageHandler* message_handler = isolate->message_handler();
      message_handler->PostMessage(
          Message::New(handle, Message::kNormalPriority),
          /*before_events*/ false);
    }
  }
}

◆ PortMap

friend class PortMap

friend

Definition at line 214 of file message_handler.h.

The documentation for this class was generated from the following files:

third_party/dart-lang/sdk/runtime/vm/message_handler.h
third_party/dart-lang/sdk/runtime/vm/message_handler.cc

Classes

Public Types

Public Member Functions

Static Public Member Functions

Protected Member Functions

Friends

Detailed Description

Member Typedef Documentation

◆ CallbackData

◆ EndCallback

◆ StartCallback

Member Enumeration Documentation

◆ MessageStatus

Constructor & Destructor Documentation

◆ MessageHandler()

◆ ~MessageHandler()

Member Function Documentation

◆ CloseAllPorts()

◆ ClosePort()

◆ DebugDump()

◆ decrement_paused()

◆ HandleMessage()

◆ HandleNextMessage()

◆ HandleOOBMessages()

◆ HasMessages()

◆ HasOOBMessages()

◆ increment_paused()

◆ is_paused_on_exit()

◆ is_paused_on_start()

◆ IsCurrentIsolate()

◆ isolate()

◆ KeepAliveLocked()

◆ MessageNotify()

◆ MessageStatusString()

◆ name()

◆ NotifyPauseOnExit()

◆ NotifyPauseOnStart()

◆ PauseAndHandleAllMessages()

◆ paused()

◆ paused_timestamp()

◆ PausedOnExit()

◆ PausedOnStart()

◆ PostMessage()

◆ RequestDeletion()

◆ Run()

◆ set_should_pause_on_exit()

◆ set_should_pause_on_start()

◆ should_pause_on_exit()

◆ should_pause_on_start()

◆ ShouldPauseOnExit()

◆ ShouldPauseOnStart()

◆ thread()

Friends And Related Symbol Documentation

◆ MessageHandlerTask

◆ MessageHandlerTestPeer

◆ MournFinalizerEntry

◆ PortMap