Cleanup options for use of application snapshots

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 26 matching lines @@
 // vm_isolate_snapshot_buffer points to a snapshot for the vm isolate if we
 // link in a snapshot otherwise it is initialized to NULL.
 extern const uint8_t* vm_isolate_snapshot_buffer;
 
 // isolate_snapshot_buffer points to a snapshot for an isolate if we link in a
 // snapshot otherwise it is initialized to NULL.
 extern const uint8_t* isolate_snapshot_buffer;
 
 /**
  * Global state used to control and store generation of application snapshots
- * (script/full).
- * A full application snapshot can be generated and run using the following
- * commands
- * - Generating a full application snapshot :
- * dart_bootstrap --full-snapshot-after-run=<filename> --package-root=<dirs>
- *   <script_uri> [<script_options>]
- * - Running the full application snapshot generated above :
- * dart --run-full-snapshot=<filename> <script_uri> [<script_options>]
+ * An application snapshot can be generated and run using the following
+ * command
+ *   dart --snapshot-kind=app-jit --snapshot=<app_snapshot_filename>
+ *       <script_uri> [<script_options>]
+ * To Run the application snapshot generated above, use :
+ *   dart <app_snapshot_filename> [<script_options>]
  */
 static bool run_app_snapshot = false;
 static const char* snapshot_filename = NULL;
 enum SnapshotKind {
   kNone,
   kScript,
   kAppAOT,
-  kAppJITAfterRun,
-  kAppAfterRun,
+  kAppJIT,
 };
 static SnapshotKind gen_snapshot_kind = kNone;
 
 // 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
@@ skipping 279 matching lines @@
 
 
 static bool ProcessSnapshotKindOption(const char* kind,
                                       CommandLineOptions* vm_options) {
   if (strcmp(kind, "script") == 0) {
     gen_snapshot_kind = kScript;
     return true;
   } else if (strcmp(kind, "app-aot") == 0) {
     gen_snapshot_kind = kAppAOT;
     return true;
-  } else if (strcmp(kind, "app-jit-after-run") == 0) {
-    gen_snapshot_kind = kAppJITAfterRun;
-    return true;
-  } else if (strcmp(kind, "app-after-run") == 0) {
-    gen_snapshot_kind = kAppAfterRun;
+  } else if (strcmp(kind, "app-jit") == 0) {
+    gen_snapshot_kind = kAppJIT;
     return true;
   }
   Log::PrintErr("Unrecognized snapshot kind: '%s'\nValid kinds are: "
-                "script, app-aot, app-jit-after-run, app-after-run\n", kind);
+                "script, app-aot, app-jit\n", kind);
   return false;
 }
 
 
 static bool ProcessEnableVmServiceOption(const char* option_value,
                                          CommandLineOptions* vm_options) {
   ASSERT(option_value != NULL);
 
   if (!ExtractPortAndIP(option_value,
                         &vm_service_server_port,
@@ skipping 415 matching lines @@
   const bool run_service_isolate = true;
 #endif  // PRODUCT
   if (!run_service_isolate &&
       (strcmp(script_uri, DART_VM_SERVICE_ISOLATE_NAME) == 0)) {
     return NULL;
   }
 
   IsolateData* isolate_data = new IsolateData(script_uri,
                                               package_root,
                                               packages_config);
-  if ((gen_snapshot_kind == kAppAfterRun) ||
-      (gen_snapshot_kind == kAppJITAfterRun)) {
+  if (gen_snapshot_kind == kAppJIT) {
     isolate_data->set_exit_hook(SnapshotOnExitHook);
   }
   Dart_Isolate isolate = Dart_CreateIsolate(script_uri,
                                             main,
                                             isolate_snapshot_buffer,
                                             flags,
                                             isolate_data,
                                             error);
   if (isolate == NULL) {
     delete isolate_data;
@@ skipping 333 matching lines @@
   int64_t data[File::kStatSize];
   File::Stat(url + 7, data);
   if (data[File::kType] == File::kDoesNotExist) {
     return true;
   }
   bool modified = data[File::kModifiedTime] > since;
   return modified;
 }
 
 
-static void WriteSnapshotFile(const char* snapshot_directory,
-                              const char* filename,
+static void WriteSnapshotFile(const char* filename,
                               bool write_magic_number,
                               const uint8_t* buffer,
                               const intptr_t size) {
   char* concat = NULL;
-  const char* qualified_filename;
-  if ((snapshot_directory != NULL) && (strlen(snapshot_directory) > 0)) {
-    intptr_t len = snprintf(NULL, 0, "%s/%s", snapshot_directory, filename);
-    concat = new char[len + 1];
-    snprintf(concat, len + 1, "%s/%s", snapshot_directory, filename);
-    qualified_filename = concat;
-  } else {
-    qualified_filename = filename;
-  }
-
-  File* file = File::Open(qualified_filename, File::kWriteTruncate);
+  File* file = File::Open(filename, File::kWriteTruncate);
   if (file == NULL) {
     ErrorExit(kErrorExitCode,
               "Unable to open file %s for writing snapshot\n",
-              qualified_filename);
+              filename);
   }
 
   if (write_magic_number) {
     // Write the magic number to indicate file is a script snapshot.
     DartUtils::WriteMagicNumber(file);
   }
 
   if (!file->WriteFully(buffer, size)) {
     ErrorExit(kErrorExitCode,
               "Unable to write file %s for writing snapshot\n",
-              qualified_filename);
+              filename);
   }
   file->Release();
   if (concat != NULL) {
     delete concat;
   }
 }
 
 
 static const int64_t kAppSnapshotHeaderSize = 5 * sizeof(int64_t);  // NOLINT
 static const int64_t kAppSnapshotMagicNumber = 0xf6f6dcdc;
@@ skipping 193 matching lines @@
 
 static void GenerateScriptSnapshot() {
   // First create a snapshot.
   uint8_t* buffer = NULL;
   intptr_t size = 0;
   Dart_Handle result = Dart_CreateScriptSnapshot(&buffer, &size);
   if (Dart_IsError(result)) {
     ErrorExit(kErrorExitCode, "%s\n", Dart_GetError(result));
   }
 
-  WriteSnapshotFile(NULL, snapshot_filename, true, buffer, size);
+  WriteSnapshotFile(snapshot_filename, true, buffer, size);
 }
 
 
 static void GeneratePrecompiledSnapshot() {
   uint8_t* vm_isolate_buffer = NULL;
   intptr_t vm_isolate_size = 0;
   uint8_t* isolate_buffer = NULL;
   intptr_t isolate_size = 0;
   uint8_t* assembly_buffer = NULL;
   intptr_t assembly_size = 0;
@@ skipping 24 matching lines @@
     WriteAppSnapshot(snapshot_filename,
                      vm_isolate_buffer,
                      vm_isolate_size,
                      isolate_buffer,
                      isolate_size,
                      instructions_blob_buffer,
                      instructions_blob_size,
                      rodata_blob_buffer,
                      rodata_blob_size);
   } else {
-    WriteSnapshotFile(NULL, snapshot_filename,
+    WriteSnapshotFile(snapshot_filename,
                       false,
                       assembly_buffer,
                       assembly_size);
   }
 }
 
 
 static void GeneratePrecompiledJITSnapshot() {
   uint8_t* vm_isolate_buffer = NULL;
   intptr_t vm_isolate_size = 0;
@@ skipping 20 matching lines @@
                    vm_isolate_size,
                    isolate_buffer,
                    isolate_size,
                    instructions_blob_buffer,
                    instructions_blob_size,
                    rodata_blob_buffer,
                    rodata_blob_size);
 }
 
 
-static void GenerateFullSnapshot() {
-  // Create a full snapshot of the script.
+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();
+#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)) {
     ErrorExit(kErrorExitCode, "%s\n", Dart_GetError(result));
   }
 
   WriteAppSnapshot(snapshot_filename,
                    vm_isolate_buffer,
                    vm_isolate_size,
                    isolate_buffer,
                    isolate_size,
                    NULL, 0, NULL, 0);
+#endif  // defined(TARGET_ARCH_X64)
 }
 
 
+
 #define CHECK_RESULT(result)                                                   \
   if (Dart_IsError(result)) {                                                  \
     if (Dart_IsVMRestartRequest(result)) {                                     \
       Dart_ExitScope();                                                        \
       Dart_ShutdownIsolate();                                                  \
       return true;                                                             \
     }                                                                          \
     const int exit_code = Dart_IsCompilationError(result) ?                    \
         kCompilationErrorExitCode : kErrorExitCode;                            \
     ErrorExit(exit_code, "%s\n", Dart_GetError(result));                       \
   }
 
 
 static void SnapshotOnExitHook(int64_t exit_code) {
   if (exit_code == 0) {
-    if (gen_snapshot_kind == kAppAfterRun) {
-      GenerateFullSnapshot();
-    } else {
-      Dart_PrecompileJIT();
-      GeneratePrecompiledJITSnapshot();
-    }
+    GenerateAppSnapshot();
   }
 }
 
 
 bool RunMainIsolate(const char* script_name,
                     CommandLineOptions* dart_options) {
   // Call CreateIsolateAndSetup which creates an isolate and loads up
   // the specified application script.
   char* error = NULL;
   int exit_code = 0;
@@ skipping 37 matching lines @@
   } else {
     // Lookup the library of the root script.
     Dart_Handle root_lib = Dart_RootLibrary();
     // Import the root library into the builtin library so that we can easily
     // lookup the main entry point exported from the root library.
     IsolateData* isolate_data =
         reinterpret_cast<IsolateData*>(Dart_IsolateData(isolate));
     result = Dart_LibraryImportLibrary(
         isolate_data->builtin_lib(), root_lib, Dart_Null());
     if (is_noopt ||
-        (gen_snapshot_kind == kAppAfterRun) ||
         (gen_snapshot_kind == kAppAOT) ||
-        (gen_snapshot_kind == kAppJITAfterRun)) {
+        (gen_snapshot_kind == kAppJIT)) {
       // Load the embedder's portion of the VM service's Dart code so it will
       // be included in the app snapshot.
       if (!VmService::LoadForGenPrecompiled()) {
         fprintf(stderr,
                 "VM service loading failed: %s\n",
                 VmService::GetErrorMessage());
         fflush(stderr);
         exit(kErrorExitCode);
       }
     }
@@ skipping 81 matching lines @@
       Dart_Handle isolate_lib =
           Dart_LookupLibrary(Dart_NewStringFromCString("dart:isolate"));
       result = Dart_Invoke(isolate_lib,
                            Dart_NewStringFromCString("_startMainIsolate"),
                            kNumIsolateArgs, isolate_args);
       CHECK_RESULT(result);
 
       // 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 == kAppAfterRun) ||
-          (gen_snapshot_kind == kAppJITAfterRun)) {
+      if ((gen_snapshot_kind == kAppJIT)) {
         if (!Dart_IsCompilationError(result) &&
             !Dart_IsVMRestartRequest(result)) {
-          if (gen_snapshot_kind == kAppAfterRun) {
-            GenerateFullSnapshot();
-          } else {
-            Dart_Handle prepare_result = Dart_PrecompileJIT();
-            CHECK_RESULT(prepare_result);
-            GeneratePrecompiledJITSnapshot();
-          }
+          GenerateAppSnapshot();
         }
       }
       CHECK_RESULT(result);
     }
   }
 
   Dart_ExitScope();
   // Shutdown the isolate.
   Dart_ShutdownIsolate();
 
@@ skipping 157 matching lines @@
     run_app_snapshot = true;
   }
 
 #if !defined(PRODUCT) && !defined(DART_PRECOMPILED_RUNTIME)
   // Constant true if PRODUCT or DART_PRECOMPILED_RUNTIME.
   if ((gen_snapshot_kind != kNone) || run_app_snapshot) {
     vm_options.AddArgument("--load_deferred_eagerly");
   }
 #endif
 
-  if (gen_snapshot_kind == kAppJITAfterRun) {
+  if (gen_snapshot_kind == kAppJIT) {
     vm_options.AddArgument("--fields_may_be_reset");
   }
   if ((gen_snapshot_kind == kAppAOT) || is_noopt) {
     vm_options.AddArgument("--precompilation");
   }
 #if defined(DART_PRECOMPILED_RUNTIME)
   vm_options.AddArgument("--precompilation");
 #endif
 
   Dart_SetVMFlags(vm_options.count(), vm_options.arguments());
@@ skipping 69 matching lines @@
   Platform::Exit(Process::GlobalExitCode());
 }
 
 }  // namespace bin
 }  // namespace dart
 
 int main(int argc, char** argv) {
   dart::bin::main(argc, argv);
   UNREACHABLE();
 }