Reapply "Save and restore feedback from JIT."

runtime/bin/main.cc

 // Copyright (c) 2012, 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 <stdlib.h>
 #include <string.h>
 #include <stdio.h>
 
 #include "include/dart_api.h"
 #include "include/dart_tools_api.h"
@@ skipping 47 matching lines @@
   kScript,
   kAppAOT,
   kAppJIT,
 };
 static SnapshotKind gen_snapshot_kind = kNone;
 
 static bool use_dart_frontend = false;
 
 static const char* frontend_filename = NULL;
 
+// Value of the --save-feedback flag.
+// (This pointer points into an argv buffer and does not need to be
+// free'd.)
+static const char* save_feedback_filename = NULL;
+
+// Value of the --load-feedback flag.
+// (This pointer points into an argv buffer and does not need to be
+// free'd.)
+static const char* load_feedback_filename = NULL;
+
 // Value of the --package-root flag.
 // (This pointer points into an argv buffer and does not need to be
 // free'd.)
 static const char* commandline_package_root = NULL;
 
 // Value of the --packages flag.
 // (This pointer points into an argv buffer and does not need to be
 // free'd.)
 static const char* commandline_packages_file = NULL;
 
@@ skipping 136 matching lines @@
                                   CommandLineOptions* vm_options) {
   ASSERT(arg != NULL);
   if (*arg == '-') {
     return false;
   }
   commandline_packages_file = arg;
   return true;
 }
 
 
+static bool ProcessSaveFeedbackOption(const char* arg,
+                                      CommandLineOptions* vm_options) {
+  ASSERT(arg != NULL);
+  if (*arg == '-') {
+    return false;
+  }
+  save_feedback_filename = arg;
+  return true;
+}
+
+
+static bool ProcessLoadFeedbackOption(const char* arg,
+                                      CommandLineOptions* vm_options) {
+  ASSERT(arg != NULL);
+  if (*arg == '-') {
+    return false;
+  }
+  load_feedback_filename = arg;
+  return true;
+}
+
+
 static void* GetHashmapKeyFromString(char* key) {
   return reinterpret_cast<void*>(key);
 }
 
 
 static bool ExtractPortAndAddress(const char* option_value,
                                   int* out_port,
                                   const char** out_ip,
                                   int default_port,
                                   const char* default_ip) {
@@ skipping 323 matching lines @@
     // VM specific options to the standalone dart program.
     {"--compile_all", ProcessCompileAllOption},
     {"--parse_all", ProcessParseAllOption},
     {"--dfe=", ProcessFrontendOption},
     {"--enable-vm-service", ProcessEnableVmServiceOption},
     {"--disable-service-origin-check", ProcessDisableServiceOriginCheckOption},
     {"--observe", ProcessObserveOption},
     {"--snapshot=", ProcessSnapshotFilenameOption},
     {"--snapshot-kind=", ProcessSnapshotKindOption},
     {"--use-blobs", ProcessUseBlobsOption},
+    {"--save-feedback=", ProcessSaveFeedbackOption},
+    {"--load-feedback=", ProcessLoadFeedbackOption},
     {"--trace-loading", ProcessTraceLoadingOption},
     {"--hot-reload-test-mode", ProcessHotReloadTestModeOption},
     {"--hot-reload-rollback-test-mode", ProcessHotReloadRollbackTestModeOption},
     {"--short_socket_read", ProcessShortSocketReadOption},
     {"--short_socket_write", ProcessShortSocketWriteOption},
 #if !defined(TARGET_OS_MACOS)
     {"--root-certs-file=", ProcessRootCertsFileOption},
     {"--root-certs-cache=", ProcessRootCertsCacheOption},
 #endif  // !defined(TARGET_OS_MACOS)
     {NULL, NULL}};
@@ skipping 913 matching lines @@
                      isolate_buffer, isolate_size, instructions_blob_buffer,
                      instructions_blob_size, rodata_blob_buffer,
                      rodata_blob_size);
   } else {
     WriteSnapshotFile(snapshot_filename, false, assembly_buffer, assembly_size);
   }
 }
 
 
 #if defined(TARGET_ARCH_X64)
-static void GeneratePrecompiledJITSnapshot() {
+static void GenerateAppJITSnapshot() {
   uint8_t* vm_isolate_buffer = NULL;
   intptr_t vm_isolate_size = 0;
   uint8_t* isolate_buffer = NULL;
   intptr_t isolate_size = 0;
   uint8_t* instructions_blob_buffer = NULL;
   intptr_t instructions_blob_size = 0;
   uint8_t* rodata_blob_buffer = NULL;
   intptr_t rodata_blob_size = 0;
   Dart_Handle result = Dart_CreateAppJITSnapshot(
       &vm_isolate_buffer, &vm_isolate_size, &isolate_buffer, &isolate_size,
@@ skipping 10 matching lines @@
 #endif  // defined(TARGET_ARCH_X64)
 
 
 static void GenerateAppSnapshot() {
   Dart_Handle result;
 #if defined(TARGET_ARCH_X64)
   result = Dart_PrecompileJIT();
   if (Dart_IsError(result)) {
     ErrorExit(kErrorExitCode, "%s\n", Dart_GetError(result));
   }
-  GeneratePrecompiledJITSnapshot();
+  GenerateAppJITSnapshot();
 #else
   // Create an application snapshot of the script.
   uint8_t* vm_isolate_buffer = NULL;
   intptr_t vm_isolate_size = 0;
   uint8_t* isolate_buffer = NULL;
   intptr_t isolate_size = 0;
 
   result = Dart_CreateSnapshot(&vm_isolate_buffer, &vm_isolate_size,
                                &isolate_buffer, &isolate_size);
   if (Dart_IsError(result)) {
@@ skipping 138 matching lines @@
           {"dart:io", "_Platform", "set:_nativeScript"},
           {"dart:io", "_ProcessStartStatus", "set:_errorCode"},
           {"dart:io", "_ProcessStartStatus", "set:_errorMessage"},
           {"dart:io", "_SecureFilterImpl", "get:buffers"},
           {"dart:io", "_SecureFilterImpl", "get:ENCRYPTED_SIZE"},
           {"dart:io", "_SecureFilterImpl", "get:SIZE"},
           {"dart:vmservice_io", "::", "main"},
           {NULL, NULL, NULL}  // Must be terminated with NULL entries.
       };
 
+      uint8_t* feedback_buffer = NULL;
+      intptr_t feedback_length = 0;
+      if (load_feedback_filename != NULL) {
+        File* file = File::Open(load_feedback_filename, File::kRead);
+        if (file == NULL) {
+          ErrorExit(kErrorExitCode, "Failed to read JIT feedback.\n");
+        }
+        feedback_length = file->Length();
+        feedback_buffer = reinterpret_cast<uint8_t*>(malloc(feedback_length));
+        if (!file->ReadFully(feedback_buffer, feedback_length)) {
+          ErrorExit(kErrorExitCode, "Failed to read JIT feedback.\n");
+        }
+        file->Release();
+      }
+
       const bool reset_fields = gen_snapshot_kind == kAppAOT;
-      result = Dart_Precompile(standalone_entry_points, reset_fields);
+      result = Dart_Precompile(standalone_entry_points, reset_fields,
+                               feedback_buffer, feedback_length);
+      if (feedback_buffer != NULL) {
+        free(feedback_buffer);
+      }
       CHECK_RESULT(result);
     }
 
     if (gen_snapshot_kind == kAppAOT) {
       GeneratePrecompiledSnapshot();
     } else {
       if (Dart_IsNull(root_lib)) {
         ErrorExit(kErrorExitCode, "Unable to find root library for '%s'\n",
                   script_name);
       }
@@ skipping 23 matching lines @@
       // Keep handling messages until the last active receive port is closed.
       result = Dart_RunLoop();
       // Generate an app snapshot after execution if specified.
       if (gen_snapshot_kind == kAppJIT) {
         if (!Dart_IsCompilationError(result) &&
             !Dart_IsVMRestartRequest(result)) {
           GenerateAppSnapshot();
         }
       }
       CHECK_RESULT(result);
+
+      if (save_feedback_filename != NULL) {
+        uint8_t* buffer = NULL;
+        intptr_t size = 0;
+        result = Dart_SaveJITFeedback(&buffer, &size);
+        if (Dart_IsError(result)) {
+          ErrorExit(kErrorExitCode, "%s\n", Dart_GetError(result));
+        }
+        WriteSnapshotFile(save_feedback_filename, false, buffer, size);
+      }
     }
   }
 
   Dart_ExitScope();
   // Shutdown the isolate.
   Dart_ShutdownIsolate();
 
   // No restart.
   return false;
 }
@@ skipping 239 matching lines @@
   Platform::Exit(Process::GlobalExitCode());
 }
 
 }  // namespace bin
 }  // namespace dart
 
 int main(int argc, char** argv) {
   dart::bin::main(argc, argv);
   UNREACHABLE();
 }