dart::CallSites Class Reference

Inheritance diagram for dart::CallSites:

Classes
struct	CallInfo

Public Member Functions
	CallSites (intptr_t threshold, GrowableArray< CallInfo< InstanceCallInstr > > *calls)
const GrowableArray< CallInfo< PolymorphicInstanceCallInstr > > &	instance_calls () const
const GrowableArray< CallInfo< StaticCallInstr > > &	static_calls () const
const GrowableArray< CallInfo< ClosureCallInstr > > &	closure_calls () const
bool	HasCalls () const
intptr_t	NumCalls () const
void	Clear ()
void	ComputeCallSiteRatio (intptr_t static_calls_start_ix, intptr_t instance_calls_start_ix, intptr_t calls_start_ix)
void	TryDevirtualize (FlowGraph *graph)
void	FindCallSites (FlowGraph *graph, intptr_t depth, GrowableArray< InlinedInfo > *inlined_info)
Public Member Functions inherited from dart::ValueObject
	ValueObject ()
	~ValueObject ()

Static Public Member Functions
template<typename CallType >
static intptr_t	ComputeMaxCallCount (const GrowableArray< CallInfo< CallType > > &calls, intptr_t start_index)
template<typename CallType >
static void	ComputeCallRatio (GrowableArray< CallInfo< CallType > > &calls, intptr_t start_index, intptr_t max_count)
static void	RecordAllNotInlinedFunction (FlowGraph *graph, intptr_t depth, GrowableArray< InlinedInfo > *inlined_info)
template<typename CallType >
static void	PruneRemovedCallsIn (GrowableArray< CallInfo< CallType > > *arr)

Detailed Description

Definition at line 261 of file inliner.cc.

Constructor & Destructor Documentation

CallSites()

dart::CallSites::CallSites ( intptr_t  threshold, GrowableArray< CallInfo< InstanceCallInstr > > *  calls  )

inlineexplicit

Definition at line 290 of file inliner.cc.

      : inlining_depth_threshold_(threshold),
        static_calls_(),
        closure_calls_(),
        instance_calls_(),
        calls_(calls) {}

Member Function Documentation

Clear()

void dart::CallSites::Clear ( )

inline

Definition at line 321 of file inliner.cc.

               {
    static_calls_.Clear();
    closure_calls_.Clear();
    instance_calls_.Clear();
  }

closure_calls()

const GrowableArray< CallInfo< ClosureCallInstr > > & dart::CallSites::closure_calls ( ) const

inline

Definition at line 307 of file inliner.cc.

                                                                         {
    return closure_calls_;
  }

ComputeCallRatio()

template<typename CallType >

static void dart::CallSites::ComputeCallRatio ( GrowableArray< CallInfo< CallType > > &  calls, intptr_t  start_index, intptr_t  max_count  )

inlinestatic

Definition at line 342 of file inliner.cc.

                                                   {
    for (intptr_t i = start_index; i < calls.length(); ++i) {
      calls[i].ratio = static_cast<double>(calls[i].call_count) / max_count;
    }
  }

ComputeCallSiteRatio()

void dart::CallSites::ComputeCallSiteRatio ( intptr_t  static_calls_start_ix, intptr_t  instance_calls_start_ix, intptr_t  calls_start_ix  )

inline

Definition at line 354 of file inliner.cc.

                                                     {
    intptr_t max_count = 0;
    max_count = Utils::Maximum(
        max_count,
        ComputeMaxCallCount(instance_calls_, instance_calls_start_ix));
    max_count = Utils::Maximum(
        max_count, ComputeMaxCallCount(static_calls_, static_calls_start_ix));
    max_count =
        Utils::Maximum(max_count, ComputeMaxCallCount(*calls_, calls_start_ix));
 
    if (max_count == 0) {
      return;
    }
 
    ComputeCallRatio(instance_calls_, instance_calls_start_ix, max_count);
    ComputeCallRatio(static_calls_, static_calls_start_ix, max_count);
    ComputeCallRatio(*calls_, calls_start_ix, max_count);
  }

ComputeMaxCallCount()

template<typename CallType >

static intptr_t dart::CallSites::ComputeMaxCallCount ( const GrowableArray< CallInfo< CallType > > &  calls, intptr_t  start_index  )

inlinestatic

Definition at line 328 of file inliner.cc.

                            {
    intptr_t max_count = 0;
    for (intptr_t i = start_index; i < calls.length(); ++i) {
      const auto count = calls[i].call_count;
      if (count > max_count) {
        max_count = count;
      }
    }
    return max_count;
  }

FindCallSites()

void dart::CallSites::FindCallSites ( FlowGraph *  graph, intptr_t  depth, GrowableArray< InlinedInfo > *  inlined_info  )

inline

Definition at line 543 of file inliner.cc.

                                                               {
    COMPILER_TIMINGS_TIMER_SCOPE(graph->thread(), FindCallSites);
    ASSERT(graph != nullptr);
    if (depth > inlining_depth_threshold_) {
      if (FLAG_print_inlining_tree) {
        RecordAllNotInlinedFunction(graph, depth, inlined_info);
      }
      return;
    }
 
    // At the maximum inlining depth, only profitable methods
    // are further considered for inlining.
    const bool inline_only_profitable_methods =
        (depth >= inlining_depth_threshold_);
 
    // In AOT, compute loop hierarchy.
    const bool is_aot = CompilerState::Current().is_aot();
    if (is_aot) {
      graph->GetLoopHierarchy();
    }
 
    const intptr_t instance_calls_start_ix = instance_calls_.length();
    const intptr_t static_calls_start_ix = static_calls_.length();
    const intptr_t calls_start_ix = calls_->length();
    for (BlockIterator block_it = graph->postorder_iterator(); !block_it.Done();
         block_it.Advance()) {
      BlockEntryInstr* entry = block_it.Current();
      const intptr_t nesting_depth = entry->NestingDepth();
      for (auto current : entry->instructions()) {
        if (auto instance_call = current->AsPolymorphicInstanceCall()) {
          if (!inline_only_profitable_methods ||
              instance_call->IsSureToCallSingleRecognizedTarget() ||
              instance_call->HasOnlyDispatcherOrImplicitAccessorTargets()) {
            // Consider instance call for further inlining. Note that it will
            // still be subject to all the inlining heuristics.
            instance_calls_.Add({graph, instance_call, depth, nesting_depth});
          } else {
            // No longer consider the instance call because inlining is too
            // deep and the method is not deemed profitable by other criteria.
            if (FLAG_print_inlining_tree) {
              const Function* caller = &graph->function();
              const Function* target = &instance_call->targets().FirstTarget();
              inlined_info->Add(InlinedInfo(caller, target, depth + 1,
                                            instance_call, "Too deep"));
            }
          }
        } else if (auto call = current->AsInstanceCall()) {
          calls_->Add({graph, call, depth, nesting_depth});
        } else if (auto static_call = current->AsStaticCall()) {
          HandleStaticCall(static_call, inline_only_profitable_methods, graph,
                           depth, nesting_depth, inlined_info);
        } else if (auto closure_call = current->AsClosureCall()) {
          if (!inline_only_profitable_methods) {
            // Consider closure for further inlining. Note that it will
            // still be subject to all the inlining heuristics.
            closure_calls_.Add({graph, closure_call, depth, nesting_depth});
          } else {
            // No longer consider the closure because inlining is too deep.
          }
        }
      }
    }
    ComputeCallSiteRatio(static_calls_start_ix, instance_calls_start_ix,
                         calls_start_ix);
  }

HasCalls()

bool dart::CallSites::HasCalls ( ) const

inline

Definition at line 311 of file inliner.cc.

                        {
    return !(static_calls_.is_empty() && closure_calls_.is_empty() &&
             instance_calls_.is_empty());
  }

instance_calls()

const GrowableArray< CallInfo< PolymorphicInstanceCallInstr > > & dart::CallSites::instance_calls ( ) const

inline

Definition at line 298 of file inliner.cc.

            {
    return instance_calls_;
  }

NumCalls()

intptr_t dart::CallSites::NumCalls ( ) const

inline

Definition at line 316 of file inliner.cc.

                            {
    return instance_calls_.length() + static_calls_.length() +
           closure_calls_.length();
  }

PruneRemovedCallsIn()

template<typename CallType >

static void dart::CallSites::PruneRemovedCallsIn ( GrowableArray< CallInfo< CallType > > *  arr )

inlinestatic

Definition at line 408 of file inliner.cc.

                                                                          {
    intptr_t j = 0;
    for (intptr_t i = 0; i < arr->length(); i++) {
      if ((*arr)[i].call->previous() != nullptr) {
        if (i != j) {
          (*arr)[j] = (*arr)[i];
        }
        j++;
      }
    }
    arr->TruncateTo(j);
  }

RecordAllNotInlinedFunction()

static void dart::CallSites::RecordAllNotInlinedFunction ( FlowGraph *  graph, intptr_t  depth, GrowableArray< InlinedInfo > *  inlined_info  )

inlinestatic

Definition at line 375 of file inliner.cc.

                                                {
    const Function* caller = &graph->function();
    Function& target = Function::ZoneHandle();
    for (BlockIterator block_it = graph->postorder_iterator(); !block_it.Done();
         block_it.Advance()) {
      for (ForwardInstructionIterator it(block_it.Current()); !it.Done();
           it.Advance()) {
        Instruction* current = it.Current();
        Definition* call = nullptr;
        if (current->IsPolymorphicInstanceCall()) {
          PolymorphicInstanceCallInstr* instance_call =
              current->AsPolymorphicInstanceCall();
          target = instance_call->targets().FirstTarget().ptr();
          call = instance_call;
        } else if (current->IsStaticCall()) {
          StaticCallInstr* static_call = current->AsStaticCall();
          target = static_call->function().ptr();
          call = static_call;
        } else if (current->IsClosureCall()) {
          // TODO(srdjan): Add data for closure calls.
        }
        if (call != nullptr) {
          inlined_info->Add(
              InlinedInfo(caller, &target, depth + 1, call, "Too deep"));
        }
      }
    }
  }

static_calls()

const GrowableArray< CallInfo< StaticCallInstr > > & dart::CallSites::static_calls ( ) const

inline

Definition at line 303 of file inliner.cc.

                                                                       {
    return static_calls_;
  }

TryDevirtualize()

void dart::CallSites::TryDevirtualize ( FlowGraph *  graph )

inline

Definition at line 423 of file inliner.cc.

                                         {
    GrowableArray<Definition*> worklist(calls_->length());
    BitVector processed(graph->zone(), graph->current_ssa_temp_index());
 
    auto add_to_worklist = [&](Definition* defn) {
      ASSERT(defn->HasSSATemp());
      const auto ssa_index = defn->ssa_temp_index();
      if (ssa_index < processed.length() && !processed.Contains(ssa_index)) {
        processed.Add(ssa_index);
        worklist.Add(defn);
        return true;
      }
      return false;
    };
 
    auto add_transitive_dependencies_to_worklist = [&](intptr_t from_index) {
      // Caveat: worklist is growing as we are iterating over it. This loop
      // goes up to |worklist.length()| and thus is going to visit all newly
      // added definitions and add their dependencies to the worklist
      // transitively.
      for (intptr_t i = from_index; i < worklist.length(); i++) {
        auto defn = worklist[i];
        for (auto input : defn->inputs()) {
          add_to_worklist(input);
        }
        // For instructions with arguments we don't expect push arguments to
        // be inserted yet.
        ASSERT(defn->ArgumentCount() == 0 || !defn->HasMoveArguments());
      }
    };
 
    // Step 1: add all calls to worklist and then transitively add all
    // their dependencies (values that flow into inputs). Calls will
    // form the prefix of the worklist followed by their inputs.
    for (auto& call_info : *calls_) {
      // Call might not have an SSA temp assigned because its result is
      // not used. We still want to add such call to worklist but we
      // should not try to update the bitvector.
      if (call_info.call->HasSSATemp()) {
        add_to_worklist(call_info.call);
      } else {
        worklist.Add(call_info.call);
      }
    }
    RELEASE_ASSERT(worklist.length() == calls_->length());
    add_transitive_dependencies_to_worklist(0);
 
    // Step 2: canonicalize each definition from the worklist. We process
    // worklist backwards which means we will usually canonicalize inputs before
    // we canonicalize the instruction that uses them.
    // Note: worklist is not topologically sorted, so we might end up
    // processing some uses before the defs.
    bool changed = false;
    intptr_t last_unhandled_call_index = calls_->length() - 1;
    while (!worklist.is_empty()) {
      auto defn = worklist.RemoveLast();
 
      // Once we reach the prefix of the worklist we know that we are processing
      // calls we are interested in.
      CallInfo<InstanceCallInstr>* call_info = nullptr;
      if (worklist.length() == last_unhandled_call_index) {
        call_info = &(*calls_)[last_unhandled_call_index];
        RELEASE_ASSERT(call_info->call == defn);
        last_unhandled_call_index--;
      }
 
      // Can't apply canonicalization rule to this definition.
      if (defn->HasUnmatchedInputRepresentations() &&
          defn->SpeculativeModeOfInputs() == Instruction::kGuardInputs) {
        continue;
      }
 
      auto replacement = defn->Canonicalize(graph);
      if (replacement != defn) {
        changed = true;
        if (replacement != nullptr) {
          defn->ReplaceUsesWith(replacement);
          if (replacement->ssa_temp_index() == -1) {
            graph->EnsureSSATempIndex(defn, replacement);
          }
 
          // Add the replacement with all of its dependencies to the worklist.
          if (add_to_worklist(replacement)) {
            add_transitive_dependencies_to_worklist(worklist.length() - 1);
          }
 
          // We have devirtualized |InstanceCall| into |StaticCall| check
          // inlining heuristics and add the |StaticCall| into |static_calls_|
          // if heuristics suggest inlining.
          //
          // Note: currently |InstanceCallInstr::Canonicalize| can only return
          // a newly constructed |StaticCallInstr|, so the check below is
          // redundant (it will always succeed). Nevertheless we add it to
          // catch situations in the future when canonicalization rule is
          // strengthened.
          const bool newly_inserted =
              replacement->ssa_temp_index() >= processed.length();
          if (call_info != nullptr && replacement->IsStaticCall() &&
              newly_inserted) {
            HandleDevirtualization(call_info,
                                   replacement->Cast<StaticCallInstr>());
          }
        }
        if (auto phi = defn->AsPhi()) {
          phi->UnuseAllInputs();
          phi->block()->RemovePhi(phi);
        } else {
          defn->RemoveFromGraph();
        }
      }
    }
 
    if (changed) {
      PruneRemovedCallsIn(&instance_calls_);
      PruneRemovedCallsIn(&static_calls_);
      PruneRemovedCallsIn(&closure_calls_);
      PruneRemovedCallsIn(calls_);
    }
  }

---

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

• third_party/dart-lang/sdk/runtime/vm/compiler/backend/inliner.cc