Experimental parser: measurement fixes in lexer-shell.

src/lexer/lexer-shell.cc

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 59 matching lines @@
   for (int i = 0; i < *size;) {
     int read = static_cast<int>(fread(&chars[i], 1, *size - i, file));
     i += read;
   }
   fclose(file);
   return chars;
 }
 
 class BaselineScanner {
  public:
-  BaselineScanner(const char* fname, Isolate* isolate, Encoding encoding) {
+  BaselineScanner(const char* fname,
+                  Isolate* isolate,
+                  Encoding encoding,
+                  ElapsedTimer* timer) {
     int length = 0;
     source_ = ReadFile(fname, isolate, &length);
     unicode_cache_ = new UnicodeCache();
     scanner_ = new Scanner(unicode_cache_);
     switch (encoding) {
       case ASCII:
       case UTF8:
         stream_ = new Utf8ToUtf16CharacterStream(source_, length);
         break;
       case UTF16: {
         Handle<String> result = isolate->factory()->NewStringFromTwoByte(
             Vector<const uint16_t>(
                 reinterpret_cast<const uint16_t*>(source_),
                 length / 2));
         stream_ =
             new GenericStringUtf16CharacterStream(result, 0, result->length());
         break;
       }
       case LATIN1: {
         Handle<String> result = isolate->factory()->NewStringFromOneByte(
             Vector<const uint8_t>(source_, length));
         stream_ =
             new GenericStringUtf16CharacterStream(result, 0, result->length());
         break;
       }
       default:
         break;
     }
+    timer->Start();
     scanner_->Initialize(stream_);
   }
 
   ~BaselineScanner() {
     delete scanner_;
     delete stream_;
     delete unicode_cache_;
     delete[] source_;
   }
 
@@ skipping 10 matching lines @@
   const byte* source_;
   BufferedUtf16CharacterStream* stream_;
 };
 
 
 int main(int argc, char* argv[]) {
   v8::V8::InitializeICU();
   v8::V8::SetFlagsFromCommandLine(&argc, argv, true);
   Encoding encoding = ASCII;
   bool print_baseline = false;
+  bool run_baseline = true;
+  bool run_experimental = true;
   for (int i = 0; i < argc; ++i) {
     if (strcmp(argv[i], "--latin1") == 0) {
       encoding = LATIN1;
     } else if (strcmp(argv[i], "--utf8") == 0) {
       encoding = UTF8;
     } else if (strcmp(argv[i], "--utf16") == 0) {
       encoding = UTF16;
     } else if (strcmp(argv[i], "--ascii") == 0) {
       encoding = ASCII;
     } else if (strcmp(argv[i], "--print-baseline") == 0) {
       print_baseline = true;
+    } else if (strcmp(argv[i], "--no-baseline") == 0) {
+      run_baseline = false;
+    } else if (strcmp(argv[i], "--no-experimental") == 0) {
+      run_experimental = false;
     }
   }
   v8::Isolate* isolate = v8::Isolate::GetCurrent();
   {
     v8::HandleScope handle_scope(isolate);
     v8::Handle<v8::ObjectTemplate> global = v8::ObjectTemplate::New();
     v8::Local<v8::Context> context = v8::Context::New(isolate, NULL, global);
     ASSERT(!context.IsEmpty());
     {
       v8::Context::Scope scope(context);
       Isolate* isolate = Isolate::Current();
       HandleScope handle_scope(isolate);
-      BaselineScanner baseline(argv[1], isolate, encoding);
-      ExperimentalScanner experimental(argv[1], true, isolate);
 
       std::vector<Token::Value> baseline_tokens, experimental_tokens;
       std::vector<size_t> baseline_beg, baseline_end, experimental_beg,
           experimental_end;
       Token::Value token;
       int beg, end;
 
       TimeDelta baseline_time, experimental_time;
       ElapsedTimer timer;
-      {
-        timer.Start();
+      if (run_baseline) {
+        BaselineScanner baseline(argv[1], isolate, encoding, &timer);
         do {
           token = baseline.Next(&beg, &end);
           baseline_tokens.push_back(token);
           baseline_beg.push_back(beg);
           baseline_end.push_back(end);
         } while (token != Token::EOS);
         baseline_time = timer.Elapsed();
       }
 
-      {
+      if (run_experimental) {
+        ExperimentalScanner experimental(argv[1], true, isolate);
         timer.Start();
         do {
           token = experimental.Next();
           experimental_tokens.push_back(token);
           ExperimentalScanner::Location location = experimental.location();
           experimental_beg.push_back(location.beg_pos);
           experimental_end.push_back(location.end_pos);
         } while (token != Token::EOS);
         experimental_time = timer.Elapsed();
       }
 
       if (print_baseline) {
         printf("Baseline:\n");
         for (size_t i = 0; i < baseline_tokens.size(); ++i) {
           printf("=> %11s at (%d, %d)\n",
                  Token::Name(baseline_tokens[i]),
                  static_cast<int>(baseline_beg[i]),
                  static_cast<int>(baseline_end[i]));
         }
         printf("(Mis)matches:\n");
       }
 
-      for (size_t i = 0; i < experimental_tokens.size(); ++i) {
-        printf("=> %11s at (%d, %d)\n",
-               Token::Name(experimental_tokens[i]),
-               static_cast<int>(experimental_beg[i]),
-               static_cast<int>(experimental_end[i]));
-        if (experimental_tokens[i] != baseline_tokens[i] ||
-            experimental_beg[i] != baseline_beg[i] ||
-            experimental_end[i] != baseline_end[i]) {
-          printf("MISMATCH:\n");
-          printf("Expected: %s at (%d, %d)\n",
-                 Token::Name(baseline_tokens[i]),
-                 static_cast<int>(baseline_beg[i]),
-                 static_cast<int>(baseline_end[i]));
-          printf("Actual:   %s at (%d, %d)\n",
+      if (run_baseline && run_experimental) {
+        for (size_t i = 0; i < experimental_tokens.size(); ++i) {
+          printf("=> %11s at (%d, %d)\n",
                  Token::Name(experimental_tokens[i]),
                  static_cast<int>(experimental_beg[i]),
                  static_cast<int>(experimental_end[i]));
-          return 1;
+          if (experimental_tokens[i] != baseline_tokens[i] ||
+              experimental_beg[i] != baseline_beg[i] ||
+              experimental_end[i] != baseline_end[i]) {
+            printf("MISMATCH:\n");
+            printf("Expected: %s at (%d, %d)\n",
+                   Token::Name(baseline_tokens[i]),
+                   static_cast<int>(baseline_beg[i]),
+                   static_cast<int>(baseline_end[i]));
+            printf("Actual:   %s at (%d, %d)\n",
+                   Token::Name(experimental_tokens[i]),
+                   static_cast<int>(experimental_beg[i]),
+                   static_cast<int>(experimental_end[i]));
+            return 1;
+          }
         }
       }
       printf("No of tokens: %d\n",
              static_cast<int>(experimental_tokens.size()));
       printf("Baseline: %f ms\nExperimental %f ms\n",
              baseline_time.InMillisecondsF(),
              experimental_time.InMillisecondsF());
     }
   }
   v8::V8::Dispose();
   return 0;
 }