#include <compiler.h>

Public Member Functions
	BackgroundCompiler (IsolateGroup *isolate_group)

virtual	~BackgroundCompiler ()

bool	EnqueueCompilation (const Function &function)

void	VisitPointers (ObjectPointerVisitor *visitor)

BackgroundCompilationQueue *	function_queue () const

bool	is_running () const

void	Run ()

Static Public Member Functions
static void	Stop (IsolateGroup *isolate_group)

Friends
class	NoBackgroundCompilerScope

Detailed Description

Definition at line 120 of file compiler.h.

Constructor & Destructor Documentation

◆ BackgroundCompiler()

dart::BackgroundCompiler::BackgroundCompiler ( IsolateGroup * isolate_group )

explicit

Definition at line 1112 of file compiler.cc.

    : isolate_group_(isolate_group),
      monitor_(),
      function_queue_(new BackgroundCompilationQueue()),
      running_(false),
      done_(true),
      disabled_depth_(0) {}

◆ ~BackgroundCompiler()

dart::BackgroundCompiler::~BackgroundCompiler ( )

virtual

Definition at line 1121 of file compiler.cc.

                                        {
  delete function_queue_;
}

Member Function Documentation

◆ EnqueueCompilation()

bool dart::BackgroundCompiler::EnqueueCompilation ( const Function & function )

Definition at line 1179 of file compiler.cc.

                                                                    {
  Thread* thread = Thread::Current();
  ASSERT(thread->IsDartMutatorThread());
  ASSERT(thread->CanAcquireSafepointLocks());
 
  SafepointMonitorLocker ml(&monitor_);
  if (disabled_depth_ > 0) return false;
  if (!running_ && done_) {
    running_ = true;
    done_ = false;
    // If we ever wanted to run the BG compiler on the
    // `IsolateGroup::mutator_pool()` we would need to ensure the BG compiler
    // stops when it's idle - otherwise the [MutatorThreadPool]-based idle
    // notification would not work anymore.
    if (!Dart::thread_pool()->Run<BackgroundCompilerTask>(this)) {
      running_ = false;
      done_ = true;
      return false;
    }
  }
 
  ASSERT(running_);
  if (function_queue()->ContainsObj(function)) {
    return true;
  }
  QueueElement* elem = new QueueElement(function);
  function_queue()->Add(elem);
  ml.NotifyAll();
  return true;
}

◆ function_queue()

BackgroundCompilationQueue * dart::BackgroundCompiler::function_queue ( ) const

inline

Definition at line 136 of file compiler.h.

136{ return function_queue_; }

◆ is_running()

bool dart::BackgroundCompiler::is_running ( ) const

inline

Definition at line 137 of file compiler.h.

137{ return running_; }

◆ Run()

void dart::BackgroundCompiler::Run ( )

Definition at line 1125 of file compiler.cc.

                             {
  bool result = Thread::EnterIsolateGroupAsHelper(
      isolate_group_, Thread::kCompilerTask, /*bypass_safepoint=*/false);
  ASSERT(result);
  {
    Thread* thread = Thread::Current();
    StackZone stack_zone(thread);
    Zone* zone = stack_zone.GetZone();
    HANDLESCOPE(thread);
    Function& function = Function::Handle(zone);
    QueueElement* element = nullptr;
    {
      SafepointMonitorLocker ml(&monitor_);
      if (running_ && !function_queue()->IsEmpty()) {
        element = function_queue()->Remove();
        function ^= element->function();
      }
    }
    if (element != nullptr) {
      delete element;
      Compiler::CompileOptimizedFunction(thread, function,
                                         Compiler::kNoOSRDeoptId);
 
      // If an optimizable method is not optimized, put it back on
      // the background queue (unless it was passed to foreground).
      if ((!function.HasOptimizedCode() && function.IsOptimizable()) ||
          FLAG_stress_test_background_compilation) {
        if (Compiler::CanOptimizeFunction(thread, function)) {
          SafepointMonitorLocker ml(&monitor_);
          if (running_) {
            QueueElement* repeat_qelem = new QueueElement(function);
            function_queue()->Add(repeat_qelem);
          }
        }
      }
    }
  }
  Thread::ExitIsolateGroupAsHelper(/*bypass_safepoint=*/false);
  {
    MonitorLocker ml(&monitor_);
    if (running_ && !function_queue()->IsEmpty() &&
        Dart::thread_pool()->Run<BackgroundCompilerTask>(this)) {
      // Successfully scheduled a new task.
    } else {
      // Background compiler done. This notification must happen after the
      // thread leaves to group to avoid a shutdown race with the thread
      // registry.
      running_ = false;
      done_ = true;
      ml.NotifyAll();
    }
  }
}

◆ Stop()

static void dart::BackgroundCompiler::Stop ( IsolateGroup * isolate_group )

inlinestatic

Definition at line 125 of file compiler.h.

                                                {
    isolate_group->background_compiler()->Stop();
  }

◆ VisitPointers()

void dart::BackgroundCompiler::VisitPointers ( ObjectPointerVisitor * visitor )

Definition at line 1210 of file compiler.cc.

                                                                    {
  function_queue_->VisitObjectPointers(visitor);
}

Friends And Related Function Documentation

◆ NoBackgroundCompilerScope

friend class NoBackgroundCompilerScope

friend

Definition at line 142 of file compiler.h.

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

third_party/dart-lang/sdk/runtime/vm/compiler/jit/compiler.h
third_party/dart-lang/sdk/runtime/vm/compiler/jit/compiler.cc

Public Member Functions

Static Public Member Functions

Friends