Recognize List constructor and turn it into CreateArray ...

runtime/vm/flow_graph_optimizer.cc

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/flow_graph_optimizer.h"
 
 #include "vm/bit_vector.h"
 #include "vm/cha.h"
 #include "vm/cpu.h"
 #include "vm/dart_entry.h"
@@ skipping 43 matching lines @@
   return FlowGraphCompiler::SupportsUnboxedSimd128();
 }
 
 
 // Optimize instance calls using ICData.
 void FlowGraphOptimizer::ApplyICData() {
   VisitBlocks();
 }
 
 
+// Optimize instructions that rely on constants.
+void FlowGraphOptimizer::ApplyConstants() {
+  ASSERT(current_iterator_ == NULL);
+  for (intptr_t i = 0; i < block_order_.length(); ++i) {
+    BlockEntryInstr* entry = block_order_[i];
+    ForwardInstructionIterator it(entry);
+    current_iterator_ = &it;
+    for (; !it.Done(); it.Advance()) {
+      Instruction* instr = it.Current();
+      if (instr->IsStaticCall()) {
+        VisitStaticCall(instr->AsStaticCall());
+      }
+    }
+    current_iterator_ = NULL;
+  }
+}
+
+
 // Optimize instance calls using cid.  This is called after optimizer
 // converted instance calls to instructions. Any remaining
 // instance calls are either megamorphic calls, cannot be optimized or
 // have no runtime type feedback collected.
 // Attempts to convert an instance call (IC call) using propagated class-ids,
 // e.g., receiver class id, guarded-cid, or by guessing cid-s.
 void FlowGraphOptimizer::ApplyClassIds() {
   ASSERT(current_iterator_ == NULL);
   for (intptr_t i = 0; i < block_order_.length(); ++i) {
     BlockEntryInstr* entry = block_order_[i];
@@ skipping 4147 matching lines @@
         new ZoneGrowableArray<Value*>(call->ArgumentCount());
     for (intptr_t i = 0; i < call->ArgumentCount(); i++) {
       args->Add(new Value(call->ArgumentAt(i)));
     }
     InvokeMathCFunctionInstr* invoke =
         new InvokeMathCFunctionInstr(args,
                                      call->deopt_id(),
                                      recognized_kind,
                                      call->token_pos());
     ReplaceCall(call, invoke);
+  } else if (recognized_kind == MethodRecognizer::kObjectArrayConstructor) {
+    Value* type = new Value(call->ArgumentAt(0));
+    Value* num_elements = new Value(call->ArgumentAt(1));
+    if (num_elements->BindsToConstant() &&
+        num_elements->BoundConstant().IsSmi()) {

[Florian Schneider, 2014/05/13 11:17:32]

Why does num_elements need to be constant? CreateArrayInstr takes an arbitrary
length operand as input.

[srdjan, 2014/05/13 18:07:18]

CreateArrayInstr expects a positive integer. Added code to handle exceptions.

[Florian Schneider, 2014/05/14 08:23:28]

Sorry to be not precise enough: I meant checking for the correct length here:
You can use CheckArrayBoundInstr for that. It will deoptmize in case of a
negative length.

Inserting the check in the allocation stub is not ideal: it can't be eliminated
there in case we actually have a constant, so it will always cost extra.

[srdjan, 2014/05/14 15:21:02]

This code is just the first step for optimized allocation in case of constants:
inline allocation code skipping all kind of checks and object tag computations.
This especially visible in case of frequent growable array allocations
(allocates List(4)). Experimental code showed 4% improvement on Havlak.

+      const intptr_t length = Smi::Cast(num_elements->BoundConstant()).Value();
+      if (length >= 0 && length <= Array::kMaxElements) {
+        CreateArrayInstr* create_array =

[Florian Schneider, 2014/05/13 11:17:32]

How about doing this in the flow graph builder instead? _List. is a native
function, so we could just emit a CreateArrayInstr right away.

[srdjan, 2014/05/13 18:07:18]

Done.

[srdjan, 2014/05/13 18:24:44]

Actually not done. FlowGraphBuilder is run in unoptimized code as well, do not
want to add method recognition etc there.  Also, there may be requirements in
the VM that a static call in unoptimized code remains static call.

+            new CreateArrayInstr(call->token_pos(), type, num_elements);
+        ReplaceCall(call, create_array);
+      }
+    }
   } else if (Library::PrivateCoreLibName(Symbols::ClassId()).Equals(
       String::Handle(call->function().name()))) {
     // Check for core library get:_classId.
     intptr_t cid = Class::Handle(call->function().Owner()).id();
     // Currently only implemented for a subset of classes.
     ASSERT((cid == kOneByteStringCid) || (cid == kTwoByteStringCid) ||
            (cid == kExternalOneByteStringCid) ||
            (cid == kGrowableObjectArrayCid) ||
            (cid == kImmutableArrayCid) || (cid == kArrayCid));
     ConstantInstr* cid_instr = new ConstantInstr(Smi::Handle(Smi::New(cid)));
     ReplaceCall(call, cid_instr);
-  }
-
-  if (call->function().IsFactory()) {
+  } else if (call->function().IsFactory()) {
     const Class& function_class = Class::Handle(call->function().Owner());
     if ((function_class.library() == Library::CoreLibrary()) ||
         (function_class.library() == Library::TypedDataLibrary())) {
       intptr_t cid = FactoryRecognizer::ResultCid(call->function());
       switch (cid) {
         case kArrayCid: {
           Value* type = new Value(call->ArgumentAt(0));
           Value* num_elements = new Value(call->ArgumentAt(1));
           if (num_elements->BindsToConstant() &&
               num_elements->BoundConstant().IsSmi()) {
@@ skipping 5294 matching lines @@
   }
 
   // Insert materializations at environment uses.
   for (intptr_t i = 0; i < exits.length(); i++) {
     CreateMaterializationAt(exits[i], alloc, alloc->cls(), *slots);
   }
 }
 
 
 }  // namespace dart