v8::internal::OptimizedCompileJob Class Reference

#include <compiler.h>

Inheritance diagram for v8::internal::OptimizedCompileJob:

Collaboration diagram for v8::internal::OptimizedCompileJob:

Classes
struct	Timer

Public Types
enum	Status { FAILED , BAILED_OUT , SUCCEEDED }

Public Member Functions
	OptimizedCompileJob (CompilationInfo *info)
MUST_USE_RESULT Status	CreateGraph ()
MUST_USE_RESULT Status	OptimizeGraph ()
MUST_USE_RESULT Status	GenerateCode ()
Status	last_status () const
CompilationInfo *	info () const
Isolate *	isolate () const
Status	RetryOptimization (BailoutReason reason)
Status	AbortOptimization (BailoutReason reason)
void	WaitForInstall ()
bool	IsWaitingForInstall ()
Public Member Functions inherited from v8::internal::ZoneObject
	INLINE (void *operator new(size_t size, Zone *zone))
void	operator delete (void *, size_t)
void	operator delete (void *pointer, Zone *zone)

Private Member Functions
MUST_USE_RESULT Status	SetLastStatus (Status status)
void	RecordOptimizationStats ()

Private Attributes
CompilationInfo *	info_
HOptimizedGraphBuilder *	graph_builder_
HGraph *	graph_
LChunk *	chunk_
base::TimeDelta	time_taken_to_create_graph_
base::TimeDelta	time_taken_to_optimize_
base::TimeDelta	time_taken_to_codegen_
Status	last_status_
bool	awaiting_install_

Detailed Description

Definition at line 582 of file compiler.h.

Member Enumeration Documentation

Status

enum v8::internal::OptimizedCompileJob::Status

Enumerator
FAILED
BAILED_OUT
SUCCEEDED

Definition at line 592 of file compiler.h.

              {
    FAILED, BAILED_OUT, SUCCEEDED
  };

Constructor & Destructor Documentation

OptimizedCompileJob()

v8::internal::OptimizedCompileJob::OptimizedCompileJob ( CompilationInfo *  info )

inlineexplicit

Definition at line 584 of file compiler.h.

      : info_(info),
        graph_builder_(NULL),
        graph_(NULL),
        chunk_(NULL),
        last_status_(FAILED),
        awaiting_install_(false) { }

Member Function Documentation

AbortOptimization()

Status v8::internal::OptimizedCompileJob::AbortOptimization ( BailoutReason  reason )

inline

Definition at line 609 of file compiler.h.

                                                 {
    info_->AbortOptimization(reason);
    return SetLastStatus(BAILED_OUT);
  }

References v8::internal::CompilationInfo::AbortOptimization(), BAILED_OUT, info_, and SetLastStatus().

Referenced by CreateGraph(), and GenerateCode().

Here is the call graph for this function:

Here is the caller graph for this function:

CreateGraph()

OptimizedCompileJob::Status v8::internal::OptimizedCompileJob::CreateGraph

(

)

Definition at line 325 of file compiler.cc.

                                                           {
  DCHECK(info()->IsOptimizing());
  DCHECK(!info()->IsCompilingForDebugging());
 
  // We should never arrive here if optimization has been disabled on the
  // shared function info.
  DCHECK(!info()->shared_info()->optimization_disabled());
 
  // Do not use crankshaft if we need to be able to set break points.
  if (isolate()->DebuggerHasBreakPoints()) {
    return RetryOptimization(kDebuggerHasBreakPoints);
  }
 
  // Limit the number of times we re-compile a functions with
  // the optimizing compiler.
  const int kMaxOptCount =
      FLAG_deopt_every_n_times == 0 ? FLAG_max_opt_count : 1000;
  if (info()->opt_count() > kMaxOptCount) {
    return AbortOptimization(kOptimizedTooManyTimes);
  }
 
  // Due to an encoding limit on LUnallocated operands in the Lithium
  // language, we cannot optimize functions with too many formal parameters
  // or perform on-stack replacement for function with too many
  // stack-allocated local variables.
  //
  // The encoding is as a signed value, with parameters and receiver using
  // the negative indices and locals the non-negative ones.
  const int parameter_limit = -LUnallocated::kMinFixedSlotIndex;
  Scope* scope = info()->scope();
  if ((scope->num_parameters() + 1) > parameter_limit) {
    return AbortOptimization(kTooManyParameters);
  }
 
  const int locals_limit = LUnallocated::kMaxFixedSlotIndex;
  if (info()->is_osr() &&
      scope->num_parameters() + 1 + scope->num_stack_slots() > locals_limit) {
    return AbortOptimization(kTooManyParametersLocals);
  }
 
  if (scope->HasIllegalRedeclaration()) {
    return AbortOptimization(kFunctionWithIllegalRedeclaration);
  }
 
  // Check the whitelist for Crankshaft.
  if (!info()->closure()->PassesFilter(FLAG_hydrogen_filter)) {
    return AbortOptimization(kHydrogenFilter);
  }
 
  // Crankshaft requires a version of fullcode with deoptimization support.
  // Recompile the unoptimized version of the code if the current version
  // doesn't have deoptimization support already.
  // Otherwise, if we are gathering compilation time and space statistics
  // for hydrogen, gather baseline statistics for a fullcode compilation.
  bool should_recompile = !info()->shared_info()->has_deoptimization_support();
  if (should_recompile || FLAG_hydrogen_stats) {
    base::ElapsedTimer timer;
    if (FLAG_hydrogen_stats) {
      timer.Start();
    }
    if (!Compiler::EnsureDeoptimizationSupport(info())) {
      return SetLastStatus(FAILED);
    }
    if (FLAG_hydrogen_stats) {
      isolate()->GetHStatistics()->IncrementFullCodeGen(timer.Elapsed());
    }
  }
 
  DCHECK(info()->shared_info()->has_deoptimization_support());
 
  // Check the whitelist for TurboFan.
  if ((FLAG_turbo_asm && info()->shared_info()->asm_function()) ||
      info()->closure()->PassesFilter(FLAG_turbo_filter)) {
    compiler::Pipeline pipeline(info());
    pipeline.GenerateCode();
    if (!info()->code().is_null()) {
      if (FLAG_turbo_deoptimization) {
        info()->context()->native_context()->AddOptimizedCode(*info()->code());
      }
      return SetLastStatus(SUCCEEDED);
    }
  }
 
  if (FLAG_trace_hydrogen) {
    Handle<String> name = info()->function()->debug_name();
    PrintF("-----------------------------------------------------------\n");
    PrintF("Compiling method %s using hydrogen\n", name->ToCString().get());
    isolate()->GetHTracer()->TraceCompilation(info());
  }
 
  // Type-check the function.
  AstTyper::Run(info());
 
  graph_builder_ = (FLAG_hydrogen_track_positions || FLAG_trace_ic)
      ? new(info()->zone()) HOptimizedGraphBuilderWithPositions(info())
      : new(info()->zone()) HOptimizedGraphBuilder(info());
 
  Timer t(this, &time_taken_to_create_graph_);
  info()->set_this_has_uses(false);
  graph_ = graph_builder_->CreateGraph();
 
  if (isolate()->has_pending_exception()) {
    return SetLastStatus(FAILED);
  }
 
  if (graph_ == NULL) return SetLastStatus(BAILED_OUT);
 
  if (info()->HasAbortedDueToDependencyChange()) {
    // Dependency has changed during graph creation. Let's try again later.
    return RetryOptimization(kBailedOutDueToDependencyChange);
  }
 
  return SetLastStatus(SUCCEEDED);
}

References AbortOptimization(), BAILED_OUT, v8::internal::CompilationInfo::context(), v8::internal::HGraphBuilder::CreateGraph(), DCHECK, v8::internal::Compiler::EnsureDeoptimizationSupport(), FAILED, v8::internal::CompilationInfo::function(), v8::internal::compiler::Pipeline::GenerateCode(), v8::internal::Isolate::GetHStatistics(), v8::internal::Isolate::GetHTracer(), graph_, graph_builder_, v8::internal::Scope::HasIllegalRedeclaration(), info(), isolate(), v8::internal::LUnallocated::kMaxFixedSlotIndex, v8::internal::LUnallocated::kMinFixedSlotIndex, name, NULL, v8::internal::Scope::num_parameters(), v8::internal::Scope::num_stack_slots(), v8::internal::PrintF(), RetryOptimization(), v8::internal::AstTyper::Run(), v8::internal::CompilationInfo::scope(), v8::internal::CompilationInfo::set_this_has_uses(), SetLastStatus(), v8::internal::CompilationInfo::shared_info(), SUCCEEDED, time_taken_to_create_graph_, and v8::internal::CompilationInfo::zone().

Referenced by v8::internal::GetOptimizedCodeLater(), and v8::internal::GetOptimizedCodeNow().

Here is the call graph for this function:

Here is the caller graph for this function:

GenerateCode()

OptimizedCompileJob::Status v8::internal::OptimizedCompileJob::GenerateCode

(

)

Definition at line 468 of file compiler.cc.

                                                            {
  DCHECK(last_status() == SUCCEEDED);
  // TODO(turbofan): Currently everything is done in the first phase.
  if (!info()->code().is_null()) {
    RecordOptimizationStats();
    return last_status();
  }
 
  DCHECK(!info()->HasAbortedDueToDependencyChange());
  DisallowCodeDependencyChange no_dependency_change;
  DisallowJavascriptExecution no_js(isolate());
  {  // Scope for timer.
    Timer timer(this, &time_taken_to_codegen_);
    DCHECK(chunk_ != NULL);
    DCHECK(graph_ != NULL);
    // Deferred handles reference objects that were accessible during
    // graph creation.  To make sure that we don't encounter inconsistencies
    // between graph creation and code generation, we disallow accessing
    // objects through deferred handles during the latter, with exceptions.
    DisallowDeferredHandleDereference no_deferred_handle_deref;
    Handle<Code> optimized_code = chunk_->Codegen();
    if (optimized_code.is_null()) {
      if (info()->bailout_reason() == kNoReason) {
        return AbortOptimization(kCodeGenerationFailed);
      }
      return SetLastStatus(BAILED_OUT);
    }
    info()->SetCode(optimized_code);
  }
  RecordOptimizationStats();
  // Add to the weak list of optimized code objects.
  info()->context()->native_context()->AddOptimizedCode(*info()->code());
  return SetLastStatus(SUCCEEDED);
}

References AbortOptimization(), BAILED_OUT, chunk_, v8::internal::LChunk::Codegen(), v8::internal::CompilationInfo::context(), DCHECK, graph_, info(), v8::internal::Handle< T >::is_null(), isolate(), last_status(), NULL, RecordOptimizationStats(), v8::internal::CompilationInfo::SetCode(), SetLastStatus(), SUCCEEDED, and time_taken_to_codegen_.

Referenced by v8::internal::Compiler::GetConcurrentlyOptimizedCode(), and v8::internal::GetOptimizedCodeNow().

Here is the call graph for this function:

Here is the caller graph for this function:

info()

CompilationInfo* v8::internal::OptimizedCompileJob::info ( ) const

inline

Definition at line 601 of file compiler.h.

{ return info_; }

References info_.

Referenced by v8::internal::OptimizingCompilerThread::AddToOsrBuffer(), CreateGraph(), v8::internal::DisposeOptimizedCompileJob(), v8::internal::OptimizingCompilerThread::FindReadyOSRCandidate(), v8::internal::OptimizingCompilerThread::FlushInputQueue(), v8::internal::OptimizingCompilerThread::FlushOutputQueue(), GenerateCode(), v8::internal::Compiler::GetConcurrentlyOptimizedCode(), v8::internal::OptimizingCompilerThread::InstallOptimizedFunctions(), isolate(), v8::internal::OptimizingCompilerThread::IsQueuedForOSR(), OptimizeGraph(), v8::internal::OptimizingCompilerThread::QueueForOptimization(), and RecordOptimizationStats().

Here is the caller graph for this function:

isolate()

Isolate* v8::internal::OptimizedCompileJob::isolate ( ) const

inline

Definition at line 602 of file compiler.h.

{ return info()->isolate(); }

References info(), and v8::internal::CompilationInfo::isolate().

Referenced by CreateGraph(), GenerateCode(), and RecordOptimizationStats().

Here is the call graph for this function:

Here is the caller graph for this function:

IsWaitingForInstall()

bool v8::internal::OptimizedCompileJob::IsWaitingForInstall ( )

inline

Definition at line 619 of file compiler.h.

{ return awaiting_install_; }

References awaiting_install_.

Referenced by v8::internal::OptimizingCompilerThread::AddToOsrBuffer(), v8::internal::DisposeOptimizedCompileJob(), v8::internal::OptimizingCompilerThread::FindReadyOSRCandidate(), and v8::internal::OptimizingCompilerThread::IsQueuedForOSR().

Here is the caller graph for this function:

last_status()

Status v8::internal::OptimizedCompileJob::last_status ( ) const

inline

Definition at line 600 of file compiler.h.

{ return last_status_; }

References last_status_.

Referenced by GenerateCode(), v8::internal::Compiler::GetConcurrentlyOptimizedCode(), and OptimizeGraph().

Here is the caller graph for this function:

OptimizeGraph()

OptimizedCompileJob::Status v8::internal::OptimizedCompileJob::OptimizeGraph

(

)

Definition at line 441 of file compiler.cc.

                                                             {
  DisallowHeapAllocation no_allocation;
  DisallowHandleAllocation no_handles;
  DisallowHandleDereference no_deref;
  DisallowCodeDependencyChange no_dependency_change;
 
  DCHECK(last_status() == SUCCEEDED);
  // TODO(turbofan): Currently everything is done in the first phase.
  if (!info()->code().is_null()) {
    return last_status();
  }
 
  Timer t(this, &time_taken_to_optimize_);
  DCHECK(graph_ != NULL);
  BailoutReason bailout_reason = kNoReason;
 
  if (graph_->Optimize(&bailout_reason)) {
    chunk_ = LChunk::NewChunk(graph_);
    if (chunk_ != NULL) return SetLastStatus(SUCCEEDED);
  } else if (bailout_reason != kNoReason) {
    graph_builder_->Bailout(bailout_reason);
  }
 
  return SetLastStatus(BAILED_OUT);
}

References BAILED_OUT, v8::internal::HOptimizedGraphBuilder::Bailout(), chunk_, DCHECK, graph_, graph_builder_, info(), last_status(), v8::internal::LChunk::NewChunk(), NULL, SetLastStatus(), SUCCEEDED, and time_taken_to_optimize_.

Referenced by v8::internal::OptimizingCompilerThread::CompileNext(), and v8::internal::GetOptimizedCodeNow().

Here is the call graph for this function:

Here is the caller graph for this function:

RecordOptimizationStats()

void v8::internal::OptimizedCompileJob::RecordOptimizationStats ( )

private

Definition at line 504 of file compiler.cc.

                                                  {
  Handle<JSFunction> function = info()->closure();
  if (!function->IsOptimized()) {
    // Concurrent recompilation and OSR may race.  Increment only once.
    int opt_count = function->shared()->opt_count();
    function->shared()->set_opt_count(opt_count + 1);
  }
  double ms_creategraph = time_taken_to_create_graph_.InMillisecondsF();
  double ms_optimize = time_taken_to_optimize_.InMillisecondsF();
  double ms_codegen = time_taken_to_codegen_.InMillisecondsF();
  if (FLAG_trace_opt) {
    PrintF("[optimizing ");
    function->ShortPrint();
    PrintF(" - took %0.3f, %0.3f, %0.3f ms]\n", ms_creategraph, ms_optimize,
           ms_codegen);
  }
  if (FLAG_trace_opt_stats) {
    static double compilation_time = 0.0;
    static int compiled_functions = 0;
    static int code_size = 0;
 
    compilation_time += (ms_creategraph + ms_optimize + ms_codegen);
    compiled_functions++;
    code_size += function->shared()->SourceSize();
    PrintF("Compiled: %d functions with %d byte source size in %fms.\n",
           compiled_functions,
           code_size,
           compilation_time);
  }
  if (FLAG_hydrogen_stats) {
    isolate()->GetHStatistics()->IncrementSubtotals(time_taken_to_create_graph_,
                                                    time_taken_to_optimize_,
                                                    time_taken_to_codegen_);
  }
}

References v8::internal::CompilationInfo::closure(), v8::internal::Isolate::GetHStatistics(), info(), isolate(), v8::internal::PrintF(), time_taken_to_codegen_, time_taken_to_create_graph_, and time_taken_to_optimize_.

Referenced by GenerateCode().

Here is the call graph for this function:

Here is the caller graph for this function:

RetryOptimization()

Status v8::internal::OptimizedCompileJob::RetryOptimization ( BailoutReason  reason )

inline

Definition at line 604 of file compiler.h.

                                                 {
    info_->RetryOptimization(reason);
    return SetLastStatus(BAILED_OUT);
  }

References BAILED_OUT, info_, v8::internal::CompilationInfo::RetryOptimization(), and SetLastStatus().

Referenced by CreateGraph(), and v8::internal::Compiler::GetConcurrentlyOptimizedCode().

Here is the call graph for this function:

Here is the caller graph for this function:

SetLastStatus()

MUST_USE_RESULT Status v8::internal::OptimizedCompileJob::SetLastStatus ( Status  status )

inlineprivate

Definition at line 632 of file compiler.h.

                                                      {
    last_status_ = status;
    return last_status_;
  }

References last_status_.

Referenced by AbortOptimization(), CreateGraph(), GenerateCode(), OptimizeGraph(), and RetryOptimization().

Here is the caller graph for this function:

WaitForInstall()

void v8::internal::OptimizedCompileJob::WaitForInstall ( )

inline

Definition at line 614 of file compiler.h.

                        {
    DCHECK(info_->is_osr());
    awaiting_install_ = true;
  }

References awaiting_install_, DCHECK, info_, and v8::internal::CompilationInfo::is_osr().

Referenced by v8::internal::OptimizingCompilerThread::InstallOptimizedFunctions().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

awaiting_install_

bool v8::internal::OptimizedCompileJob::awaiting_install_

private

Definition at line 630 of file compiler.h.

Referenced by IsWaitingForInstall(), and WaitForInstall().

chunk_

LChunk* v8::internal::OptimizedCompileJob::chunk_

private

Definition at line 625 of file compiler.h.

Referenced by GenerateCode(), and OptimizeGraph().

graph_

HGraph* v8::internal::OptimizedCompileJob::graph_

private

Definition at line 624 of file compiler.h.

Referenced by CreateGraph(), GenerateCode(), and OptimizeGraph().

graph_builder_

HOptimizedGraphBuilder* v8::internal::OptimizedCompileJob::graph_builder_

private

Definition at line 623 of file compiler.h.

Referenced by CreateGraph(), and OptimizeGraph().

info_

CompilationInfo* v8::internal::OptimizedCompileJob::info_

private

Definition at line 622 of file compiler.h.

Referenced by AbortOptimization(), info(), RetryOptimization(), and WaitForInstall().

last_status_

Status v8::internal::OptimizedCompileJob::last_status_

private

Definition at line 629 of file compiler.h.

Referenced by last_status(), and SetLastStatus().

time_taken_to_codegen_

base::TimeDelta v8::internal::OptimizedCompileJob::time_taken_to_codegen_

private

Definition at line 628 of file compiler.h.

Referenced by GenerateCode(), and RecordOptimizationStats().

time_taken_to_create_graph_

base::TimeDelta v8::internal::OptimizedCompileJob::time_taken_to_create_graph_

private

Definition at line 626 of file compiler.h.

Referenced by CreateGraph(), and RecordOptimizationStats().

time_taken_to_optimize_

base::TimeDelta v8::internal::OptimizedCompileJob::time_taken_to_optimize_

private

Definition at line 627 of file compiler.h.

Referenced by OptimizeGraph(), and RecordOptimizationStats().

---

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

• /mnt/V8SourceCode/src/compiler.h
• /mnt/V8SourceCode/src/compiler.cc