CoreJIT snapshots without training.

runtime/bin/gen_snapshot.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.
 
 // Generate a snapshot file after loading all the scripts specified on the
 // command line.
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ skipping 40 matching lines @@
     }                                                                          \
     Dart_ExitScope();                                                          \
     Dart_ShutdownIsolate();                                                    \
     exit(exit_code);                                                           \
   }
 
 
 // The core snapshot to use when creating isolates. Normally NULL, but loaded
 // from a file when creating script snapshots.
 const uint8_t* isolate_snapshot_data = NULL;
+const uint8_t* isolate_snapshot_instructions = NULL;
 
 
 // Global state that indicates whether a snapshot is to be created and
 // if so which file to write the snapshot into.
 enum SnapshotKind {
   kCore,
+  kCoreJIT,
   kScript,
   kAppAOTBlobs,
   kAppAOTAssembly,
 };
 static SnapshotKind snapshot_kind = kCore;
 static const char* vm_snapshot_data_filename = NULL;
 static const char* vm_snapshot_instructions_filename = NULL;
 static const char* isolate_snapshot_data_filename = NULL;
 static const char* isolate_snapshot_instructions_filename = NULL;
 static const char* assembly_filename = NULL;
@@ skipping 126 matching lines @@
 
 
 static bool ProcessSnapshotKindOption(const char* option) {
   const char* kind = ProcessOption(option, "--snapshot_kind=");
   if (kind == NULL) {
     kind = ProcessOption(option, "--snapshot-kind=");
   }
   if (kind == NULL) {
     return false;
   }
-  if (strcmp(kind, "core") == 0) {
+  if (strcmp(kind, "core-jit") == 0) {
+    snapshot_kind = kCoreJIT;
+    return true;
+  } else if (strcmp(kind, "core") == 0) {
     snapshot_kind = kCore;
     return true;
   } else if (strcmp(kind, "script") == 0) {
     snapshot_kind = kScript;
     return true;
   } else if (strcmp(kind, "app-aot-blobs") == 0) {
     snapshot_kind = kAppAOTBlobs;
     return true;
   } else if (strcmp(kind, "app-aot-assembly") == 0) {
     snapshot_kind = kAppAOTAssembly;
@@ skipping 222 matching lines @@
     case kCore: {
       if ((vm_snapshot_data_filename == NULL) ||
           (isolate_snapshot_data_filename == NULL)) {
         Log::PrintErr(
             "Building a core snapshot requires specifying output files for "
             "--vm_snapshot_data and --isolate_snapshot_data.\n\n");
         return -1;
       }
       break;
     }
+    case kCoreJIT: {
+      if ((vm_snapshot_data_filename == NULL) ||
+          (vm_snapshot_instructions_filename == NULL) ||
+          (isolate_snapshot_data_filename == NULL) ||
+          (isolate_snapshot_instructions_filename == NULL)) {
+        Log::PrintErr(
+            "Building a core JIT snapshot requires specifying output "
+            "files for --vm_snapshot_data, --vm_snapshot_instructions, "
+            "--isolate_snapshot_data and --isolate_snapshot_instructions.\n\n");
+        return -1;
+      }
+      break;
+    }
     case kScript: {
       if ((vm_snapshot_data_filename == NULL) ||
           (isolate_snapshot_data_filename == NULL) ||
           (script_snapshot_filename == NULL) || (*script_name == NULL)) {
         Log::PrintErr(
             "Building a script snapshot requires specifying input files for "
             "--vm_snapshot_data and --isolate_snapshot_data, an output file "
             "for --script_snapshot, and a Dart script.\n\n");
         return -1;
       }
@@ skipping 217 matching lines @@
       case kCore:
         success &= file->Print("%s ", vm_snapshot_data_filename);
         success &= file->Print("%s ", isolate_snapshot_data_filename);
         break;
       case kScript:
         success &= file->Print("%s ", script_snapshot_filename);
         break;
       case kAppAOTAssembly:
         success &= file->Print("%s ", assembly_filename);
         break;
+      case kCoreJIT:
       case kAppAOTBlobs:
         success &= file->Print("%s ", vm_snapshot_data_filename);
         success &= file->Print("%s ", vm_snapshot_instructions_filename);
         success &= file->Print("%s ", isolate_snapshot_data_filename);
         success &= file->Print("%s ", isolate_snapshot_instructions_filename);
         break;
     }
 
     success &= file->Print(": ");
   }
@@ skipping 562 matching lines @@
   // First create a snapshot.
   result = Dart_CreateSnapshot(&vm_snapshot_data_buffer, &vm_snapshot_data_size,
                                &isolate_snapshot_data_buffer,
                                &isolate_snapshot_data_size);
   CHECK_RESULT(result);
 
   // Now write the vm isolate and isolate snapshots out to the
   // specified file and exit.
   WriteSnapshotFile(vm_snapshot_data_filename, vm_snapshot_data_buffer,
                     vm_snapshot_data_size);
+  if (vm_snapshot_instructions_filename != NULL) {
+    WriteSnapshotFile(vm_snapshot_instructions_filename, NULL, 0);
+  }
   WriteSnapshotFile(isolate_snapshot_data_filename,
                     isolate_snapshot_data_buffer, isolate_snapshot_data_size);
+  if (isolate_snapshot_instructions_filename != NULL) {
+    WriteSnapshotFile(isolate_snapshot_instructions_filename, NULL, 0);
+  }
 }
 
 
+static void CreateAndWriteCoreJITSnapshot() {
+  ASSERT(snapshot_kind == kCoreJIT);
+  ASSERT(vm_snapshot_data_filename != NULL);
+  ASSERT(vm_snapshot_instructions_filename != NULL);
+  ASSERT(isolate_snapshot_data_filename != NULL);
+  ASSERT(isolate_snapshot_instructions_filename != NULL);
+
+  Dart_Handle result;
+  uint8_t* vm_snapshot_data_buffer = NULL;
+  intptr_t vm_snapshot_data_size = 0;
+  uint8_t* vm_snapshot_instructions_buffer = NULL;
+  intptr_t vm_snapshot_instructions_size = 0;
+  uint8_t* isolate_snapshot_data_buffer = NULL;
+  intptr_t isolate_snapshot_data_size = 0;
+  uint8_t* isolate_snapshot_instructions_buffer = NULL;
+  intptr_t isolate_snapshot_instructions_size = 0;
+
+  // First create a snapshot.
+  result = Dart_CreateCoreJITSnapshotAsBlobs(
+      &vm_snapshot_data_buffer, &vm_snapshot_data_size,
+      &vm_snapshot_instructions_buffer, &vm_snapshot_instructions_size,
+      &isolate_snapshot_data_buffer, &isolate_snapshot_data_size,
+      &isolate_snapshot_instructions_buffer,
+      &isolate_snapshot_instructions_size);
+  CHECK_RESULT(result);
+
+  // Now write the vm isolate and isolate snapshots out to the
+  // specified file and exit.
+  WriteSnapshotFile(vm_snapshot_data_filename, vm_snapshot_data_buffer,
+                    vm_snapshot_data_size);
+  WriteSnapshotFile(vm_snapshot_instructions_filename,
+                    vm_snapshot_instructions_buffer,
+                    vm_snapshot_instructions_size);
+  WriteSnapshotFile(isolate_snapshot_data_filename,
+                    isolate_snapshot_data_buffer, isolate_snapshot_data_size);
+  WriteSnapshotFile(isolate_snapshot_instructions_filename,
+                    isolate_snapshot_instructions_buffer,
+                    isolate_snapshot_instructions_size);
+}
+
+
 static void CreateAndWriteScriptSnapshot() {
   ASSERT(snapshot_kind == kScript);
   ASSERT(script_snapshot_filename != NULL);
 
   // First create a snapshot.
   uint8_t* buffer = NULL;
   intptr_t size = 0;
   Dart_Handle result = Dart_CreateScriptSnapshot(&buffer, &size);
   CHECK_RESULT(result);
 
@@ skipping 91 matching lines @@
 static Dart_Isolate CreateServiceIsolate(const char* script_uri,
                                          const char* main,
                                          const char* package_root,
                                          const char* package_config,
                                          Dart_IsolateFlags* flags,
                                          void* data,
                                          char** error) {
   IsolateData* isolate_data =
       new IsolateData(script_uri, package_root, package_config, NULL);
   Dart_Isolate isolate = NULL;
-  isolate = Dart_CreateIsolate(script_uri, main, isolate_snapshot_data, NULL,
-                               NULL, isolate_data, error);
+  isolate = Dart_CreateIsolate(script_uri, main, isolate_snapshot_data,
+                               isolate_snapshot_instructions, NULL,
+                               isolate_data, error);
 
   if (isolate == NULL) {
     Log::PrintErr("Error: Could not create service isolate\n");
     return NULL;
   }
 
   Dart_EnterScope();
   if (!Dart_IsServiceIsolate(isolate)) {
     Log::PrintErr("Error: We only expect to create the service isolate\n");
     return NULL;
@@ skipping 14 matching lines @@
                         false /* trace_loading */)) {
     *error = strdup(VmService::GetErrorMessage());
     return NULL;
   }
   Dart_ExitScope();
   Dart_ExitIsolate();
   return isolate;
 }
 
 
+static MappedMemory* MapFile(const char* filename, File::MapType type) {
+  File* file = File::Open(filename, File::kRead);
+  if (file == NULL) {
+    Log::PrintErr("Failed to open: %s\n", filename);
+    exit(kErrorExitCode);
+  }
+  MappedMemory* mapping = file->Map(type, 0, file->Length());
+  if (mapping == NULL) {
+    Log::PrintErr("Failed to read: %s\n", vm_snapshot_data_filename);
+    exit(kErrorExitCode);
+  }
+  file->Release();
+  return mapping;
+}
+
+
 int main(int argc, char** argv) {
   const int EXTRA_VM_ARGUMENTS = 2;
   CommandLineOptions vm_options(argc + EXTRA_VM_ARGUMENTS);
 
   // Initialize the URL mapping array.
   CommandLineOptions cmdline_url_mapping(argc);
   DartUtils::url_mapping = &cmdline_url_mapping;
 
   // Initialize the entrypoints array.
   CommandLineOptions entry_points_files_array(argc);
@@ skipping 13 matching lines @@
   EventHandler::Start();
 
 #if !defined(PRODUCT)
   // Constant true in PRODUCT mode.
   vm_options.AddArgument("--load_deferred_eagerly");
 #endif
 
   if (IsSnapshottingForPrecompilation()) {
     vm_options.AddArgument("--precompilation");
   }
+  if (snapshot_kind == kCoreJIT) {
+    vm_options.AddArgument("--fields_may_be_reset");
+    vm_options.AddArgument("--link_natives_lazily");
+#if !defined(PRODUCT)
+    vm_options.AddArgument("--collect_code=false");
+#endif
+  }
 
   Dart_SetVMFlags(vm_options.count(), vm_options.arguments());
 
   // Initialize the Dart VM.
   // Note: We don't expect isolates to be created from dart code during
   // core library snapshot generation. However for the case when a full
   // snasphot is generated from a script (app_script_name != NULL) we will
   // need the service isolate to resolve URI and load code.
 
   Dart_InitializeParams init_params;
   memset(&init_params, 0, sizeof(init_params));
   init_params.version = DART_INITIALIZE_PARAMS_CURRENT_VERSION;
   if (app_script_name != NULL) {
     init_params.create = CreateServiceIsolate;
   }
   init_params.file_open = DartUtils::OpenFile;
   init_params.file_read = DartUtils::ReadFile;
   init_params.file_write = DartUtils::WriteFile;
   init_params.file_close = DartUtils::CloseFile;
   init_params.entropy_source = DartUtils::EntropySource;
 
   MappedMemory* mapped_vm_snapshot_data = NULL;
+  MappedMemory* mapped_vm_snapshot_instructions = NULL;
   MappedMemory* mapped_isolate_snapshot_data = NULL;
+  MappedMemory* mapped_isolate_snapshot_instructions = NULL;
   if (snapshot_kind == kScript) {
-    File* file = File::Open(vm_snapshot_data_filename, File::kRead);
-    if (file == NULL) {
-      Log::PrintErr("Failed to open: %s\n", vm_snapshot_data_filename);
-      return kErrorExitCode;
-    }
-    mapped_vm_snapshot_data = file->Map(File::kReadOnly, 0, file->Length());
-    if (mapped_vm_snapshot_data == NULL) {
-      Log::PrintErr("Failed to read: %s\n", vm_snapshot_data_filename);
-      return kErrorExitCode;
-    }
-    file->Release();
+    mapped_vm_snapshot_data =
+        MapFile(vm_snapshot_data_filename, File::kReadOnly);
     init_params.vm_snapshot_data =
         reinterpret_cast<const uint8_t*>(mapped_vm_snapshot_data->address());
 
-    file = File::Open(isolate_snapshot_data_filename, File::kRead);
-    if (file == NULL) {
-      Log::PrintErr("Failed to open: %s\n", isolate_snapshot_data_filename);
-      return kErrorExitCode;
+    if (vm_snapshot_instructions_filename != NULL) {
+      mapped_vm_snapshot_instructions =
+          MapFile(vm_snapshot_instructions_filename, File::kReadExecute);
+      init_params.vm_snapshot_instructions = reinterpret_cast<const uint8_t*>(
+          mapped_vm_snapshot_instructions->address());
     }
+
     mapped_isolate_snapshot_data =
-        file->Map(File::kReadOnly, 0, file->Length());
-    if (mapped_isolate_snapshot_data == NULL) {
-      Log::PrintErr("Failed to read: %s\n", isolate_snapshot_data_filename);
-      return kErrorExitCode;
-    }
-    file->Release();
+        MapFile(isolate_snapshot_data_filename, File::kReadOnly);
     isolate_snapshot_data = reinterpret_cast<const uint8_t*>(
         mapped_isolate_snapshot_data->address());
+
+    if (isolate_snapshot_instructions_filename != NULL) {
+      mapped_isolate_snapshot_instructions =
+          MapFile(isolate_snapshot_instructions_filename, File::kReadExecute);
+      isolate_snapshot_instructions = reinterpret_cast<const uint8_t*>(
+          mapped_isolate_snapshot_instructions->address());
+    }
   }
 
   char* error = Dart_Initialize(&init_params);
   if (error != NULL) {
     Log::PrintErr("VM initialization failed: %s\n", error);
     free(error);
     return kErrorExitCode;
   }
 
   IsolateData* isolate_data = new IsolateData(NULL, commandline_package_root,
                                               commandline_packages_file, NULL);
   Dart_Isolate isolate = Dart_CreateIsolate(NULL, NULL, isolate_snapshot_data,
-                                            NULL, NULL, isolate_data, &error);
+                                            isolate_snapshot_instructions, NULL,
+                                            isolate_data, &error);
   if (isolate == NULL) {
     Log::PrintErr("Error: %s\n", error);
     free(error);
     exit(kErrorExitCode);
   }
 
   Dart_Handle result;
   Dart_Handle library;
   Dart_EnterScope();
 
@@ skipping 44 matching lines @@
     void* kernel_program = NULL;
     if (is_kernel_file) {
       kernel_program = Dart_ReadKernelBinary(kernel, kernel_length);
       free(const_cast<uint8_t*>(kernel));
     }
 
     Dart_Isolate isolate =
         is_kernel_file
             ? Dart_CreateIsolateFromKernel(NULL, NULL, kernel_program, NULL,
                                            isolate_data, &error)
-            : Dart_CreateIsolate(NULL, NULL, isolate_snapshot_data, NULL, NULL,
+            : Dart_CreateIsolate(NULL, NULL, isolate_snapshot_data,
+                                 isolate_snapshot_instructions, NULL,
                                  isolate_data, &error);
     if (isolate == NULL) {
       Log::PrintErr("%s\n", error);
       free(error);
       exit(kErrorExitCode);
     }
     Dart_EnterScope();
     result = Dart_SetEnvironmentCallback(EnvironmentCallback);
     CHECK_RESULT(result);
 
@@ skipping 33 matching lines @@
 
     // Ensure that we mark all libraries as loaded.
     result = Dart_FinalizeLoading(false);
     CHECK_RESULT(result);
 
     if (!dependencies_only) {
       switch (snapshot_kind) {
         case kCore:
           CreateAndWriteCoreSnapshot();
           break;
+        case kCoreJIT:
+          CreateAndWriteCoreJITSnapshot();
+          break;
         case kScript:
           CreateAndWriteScriptSnapshot();
           break;
         case kAppAOTBlobs:
         case kAppAOTAssembly:
           CreateAndWritePrecompiledSnapshot(entry_points);
           break;
         default:
           UNREACHABLE();
       }
     }
 
     CreateAndWriteDependenciesFile();
 
     Dart_ExitScope();
     Dart_ShutdownIsolate();
 
     CleanupEntryPointsCollection(entry_points);
 
     Dart_EnterIsolate(UriResolverIsolateScope::isolate);
     Dart_ShutdownIsolate();
   } else {
     SetupForGenericSnapshotCreation();
-    CreateAndWriteCoreSnapshot();
+    switch (snapshot_kind) {
+      case kCore:
+        CreateAndWriteCoreSnapshot();
+        break;
+      case kCoreJIT:
+        CreateAndWriteCoreJITSnapshot();
+        break;
+      default:
+        UNREACHABLE();
+        break;
+    }
 
     Dart_ExitScope();
     Dart_ShutdownIsolate();
   }
   error = Dart_Cleanup();
   if (error != NULL) {
     Log::PrintErr("VM cleanup failed: %s\n", error);
     free(error);
   }
   EventHandler::Stop();
   delete mapped_vm_snapshot_data;
   delete mapped_isolate_snapshot_data;
   return 0;
 }
 
 }  // namespace bin
 }  // namespace dart
 
 int main(int argc, char** argv) {
   return dart::bin::main(argc, argv);
 }