Significantly improve performance of code coverage tool by precomputing a map token_pos->line numbe…

runtime/vm/coverage.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/coverage.h"
 
 #include "include/dart_api.h"
 
 #include "vm/compiler.h"
 #include "vm/isolate.h"
 #include "vm/json_stream.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 
 namespace dart {
 
 DEFINE_FLAG(charp, coverage_dir, NULL,
             "Enable writing coverage data into specified directory.");
 
 
+// map[token_pos] -> line-number.
+static void ComputeTokenPosToLineNumberMap(const Script& script,
+                                           GrowableArray<intptr_t>* map) {
+  const TokenStream& tkns = TokenStream::Handle(script.tokens());
+  const intptr_t len = ExternalTypedData::Handle(tkns.GetStream()).Length();
+  map->Clear();

[Ivan Posva, 2014/06/10 21:34:48]

map->ClearTo(-1);

+  for (intptr_t i = 0; i < len; i++) {
+    map->Add(-1);
+  }

[siva, 2014/06/10 21:31:55]

I am wondering if we should have an AddAt or EnsureCapacity method in
BaseGrowableArray, then we won't need this loop.

[srdjan, 2014/06/10 21:38:01]

Agreed. Will do in a follow-up CL.

+  TokenStream::Iterator tkit(tkns, 0, TokenStream::Iterator::kAllTokens);
+  intptr_t cur_line = script.line_offset() + 1;
+  while (tkit.CurrentTokenKind() != Token::kEOS) {
+    (*map)[tkit.CurrentPosition()] = cur_line;
+    if (tkit.CurrentTokenKind() == Token::kNEWLINE) {
+      cur_line++;
+    }
+    tkit.Advance();
+  }
+}
+
+
 void CodeCoverage::CompileAndAdd(const Function& function,
-                                 const JSONArray& hits_arr) {
+                                 const JSONArray& hits_arr,
+                                 const GrowableArray<intptr_t>& pos_to_line) {
   Isolate* isolate = Isolate::Current();
   if (!function.HasCode()) {
     // If the function should not be compiled or if the compilation failed,
     // then just skip this method.
     // TODO(iposva): Maybe we should skip synthesized methods in general too.
     if (function.is_abstract() || function.IsRedirectingFactory()) {
       return;
     }
     if (function.IsNonImplicitClosureFunction() &&
         (function.context_scope() == ContextScope::null())) {
       // TODO(iposva): This can arise if we attempt to compile an inner function
       // before we have compiled its enclosing function or if the enclosing
       // function failed to compile.
       OS::Print("### Coverage skipped compiling: %s\n", function.ToCString());
       return;
     }
     const Error& err = Error::Handle(
         isolate, Compiler::CompileFunction(isolate, function));
     if (!err.IsNull()) {
       OS::Print("### Coverage failed compiling:\n%s\n", err.ToErrorCString());
       return;
     }
   }
   ASSERT(function.HasCode());
 
   // Print the hit counts for all IC datas.
-  const Script& script = Script::Handle(function.script());
   const Code& code = Code::Handle(function.unoptimized_code());
   const Array& ic_array = Array::Handle(code.ExtractTypeFeedbackArray());
   const PcDescriptors& descriptors = PcDescriptors::Handle(
       code.pc_descriptors());
   ICData& ic_data = ICData::Handle();
 
   for (int j = 0; j < descriptors.Length(); j++) {
     HANDLESCOPE(isolate);
     PcDescriptors::Kind kind = descriptors.DescriptorKind(j);
     // Only IC based calls have counting.
     if ((kind == PcDescriptors::kIcCall) ||
         (kind == PcDescriptors::kUnoptStaticCall)) {
       intptr_t deopt_id = descriptors.DeoptId(j);
       ic_data ^= ic_array.At(deopt_id);
       if (!ic_data.IsNull()) {
         intptr_t token_pos = descriptors.TokenPos(j);
-        intptr_t line = -1;
-        script.GetTokenLocation(token_pos, &line, NULL);
+        intptr_t line = pos_to_line[token_pos];
+#if defined(DEBUG)
+        const Script& script = Script::Handle(function.script());
+        intptr_t test_line = -1;
+        script.GetTokenLocation(token_pos, &test_line, NULL);
+        ASSERT(test_line == line);
+#endif
         hits_arr.AddValue(line);
         hits_arr.AddValue(ic_data.AggregateCount());
       }
     }
   }
 }
 
 
 void CodeCoverage::PrintClass(const Class& cls, const JSONArray& jsarr) {
   Isolate* isolate = Isolate::Current();
   Array& functions = Array::Handle(cls.functions());
   ASSERT(!functions.IsNull());
   Function& function = Function::Handle();
   Script& script = Script::Handle();
   String& saved_url = String::Handle();
   String& url = String::Handle();
-
+  GrowableArray<intptr_t> pos_to_line;
   int i = 0;
   while (i < functions.Length()) {
     HANDLESCOPE(isolate);
     function ^= functions.At(i);
     JSONObject jsobj(&jsarr);
     script = function.script();
+    if (pos_to_line.is_empty()) {

[Ivan Posva, 2014/06/10 21:34:48]

always?

[srdjan, 2014/06/10 21:38:01]

Done.

+      ComputeTokenPosToLineNumberMap(script, &pos_to_line);
+    }
     saved_url = script.url();
     jsobj.AddProperty("source", saved_url.ToCString());
     jsobj.AddProperty("script", script);
     JSONArray hits_arr(&jsobj, "hits");
 
     // We stay within this loop while we are seeing functions from the same
     // source URI.
     while (i < functions.Length()) {
       function ^= functions.At(i);
       script = function.script();
       url = script.url();
       if (!url.Equals(saved_url)) {
+        pos_to_line.Clear();
         break;
       }
-      CompileAndAdd(function, hits_arr);
+      CompileAndAdd(function, hits_arr, pos_to_line);
       if (function.HasImplicitClosureFunction()) {
         function = function.ImplicitClosureFunction();
-        CompileAndAdd(function, hits_arr);
+        CompileAndAdd(function, hits_arr, pos_to_line);
       }
       i++;
     }
   }
 
   GrowableObjectArray& closures =
       GrowableObjectArray::Handle(cls.closures());
   if (!closures.IsNull()) {
     i = 0;
+    pos_to_line.Clear();
     // We need to keep rechecking the length of the closures array, as handling
     // a closure potentially adds new entries to the end.
     while (i < closures.Length()) {
       HANDLESCOPE(isolate);
       function ^= closures.At(i);
       JSONObject jsobj(&jsarr);
       script = function.script();
+      if (pos_to_line.is_empty()) {

[Ivan Posva, 2014/06/10 21:34:48]

ditto

[srdjan, 2014/06/10 21:38:01]

Done.

+        ComputeTokenPosToLineNumberMap(script, &pos_to_line);
+      }
       saved_url = script.url();
       jsobj.AddProperty("source", saved_url.ToCString());
       jsobj.AddProperty("script", script);
       JSONArray hits_arr(&jsobj, "hits");
 
       // We stay within this loop while we are seeing functions from the same
       // source URI.
       while (i < closures.Length()) {
         function ^= closures.At(i);
         script = function.script();
         url = script.url();
         if (!url.Equals(saved_url)) {
+          pos_to_line.Clear();
           break;
         }
-        CompileAndAdd(function, hits_arr);
+        CompileAndAdd(function, hits_arr, pos_to_line);
         i++;
       }
     }
   }
 }
 
 
 void CodeCoverage::Write(Isolate* isolate) {
   if (FLAG_coverage_dir == NULL) {
     return;
@@ skipping 46 matching lines @@
           // functions.
           PrintClass(cls, jsarr);
         }
       }
     }
   }
 }
 
 
 }  // namespace dart