Changes to create an application snapshot which can be layered on top

bin/main.cc

 // Copyright (c) 2011, 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_debugger_api.h"
 
 #include "bin/builtin.h"
 #include "bin/dartutils.h"
 #include "bin/file.h"
 #include "bin/globals.h"
 #include "bin/platform.h"
 
 // snapshot_buffer points to a snapshot if we link in a snapshot otherwise
 // it is initialized to NULL.
 extern const uint8_t* snapshot_buffer;
 
 
 // Global state that stores a pointer to the application script file.
 static char* canonical_script_name = NULL;
 
 
+// Global state that stores a pointer to the application script snapshot.
+static bool use_script_snapshot = false;
+static uint8_t* script_snapshot_buffer = NULL;
+
+
 // Global state that indicates whether pprof symbol information is
 // to be generated or not.
 static const char* generate_pprof_symbols_filename = NULL;
 
 
 // Global state that indicates whether there is a debug breakpoint.
 // This pointer points into an argv buffer and does not need to be
 // free'd.
 static const char* breakpoint_at = NULL;
 
 
 static bool IsValidFlag(const char* name,
                         const char* prefix,
                         intptr_t prefix_length) {
   intptr_t name_length = strlen(name);
   return ((name_length > prefix_length) &&
           (strncmp(name, prefix, prefix_length) == 0));
 }
 
 
-static const char* ProcessOption(const char* option, const char* name) {
-  const intptr_t length = strlen(name);
-  if (strncmp(option, name, length) == 0) {
-    return (option + length);
-  }
-  return NULL;
+static void ProcessPprofOption(const char* filename) {
+  ASSERT(filename != NULL);
+  generate_pprof_symbols_filename = filename;
 }
 
 
-static bool ProcessPprofOption(const char* option) {
-  const char* kProfOption = "--generate_pprof_symbols=";
-  const char* filename = ProcessOption(option, kProfOption);
-  if (filename != NULL) {
-    generate_pprof_symbols_filename = filename;
-  }
-  return filename != NULL;
+static void ProcessBreakpointOption(const char* funcname) {
+  ASSERT(funcname != NULL);
+  breakpoint_at = funcname;
 }
 
 
-static bool ProcessDebugOption(const char* option) {
-  const char* kDebugOption = "--break_at=";
-  const char* func_name = ProcessOption(option, kDebugOption);
-  if (func_name != NULL) {
-    breakpoint_at = func_name;
-  }
-  return func_name != NULL;
+static void ProcessSnapshotOption(const char* snapshot) {
+  ASSERT(snapshot != NULL);
+  use_script_snapshot = true;
 }
 
 
+static struct {
+  const char* option_name;
+  void (*process)(const char* option);
+} main_options[] = {
+  { "--generate_pprof_symbols=", ProcessPprofOption },
+  { "--break_at=", ProcessBreakpointOption },
+  { "--use_script_snapshot", ProcessSnapshotOption },

[Ivan Posva, 2011/12/19 21:32:42]

What about compile-all? In general we should figure out if we can pull these
kind of testing flags out of the production binary.

[siva, 2011/12/19 23:50:00]

Added --compile_all to this list.
As discussed off-line we could potentially move these testing flags out of the
production binary and into the binary run_vm_tests. 

On 2011/12/19 21:32:42, Ivan Posva wrote:

+  { NULL, NULL }
+};
+
+
+static bool ProcessMainOptions(const char* option) {
+  int i = 0;
+  const char* name = main_options[0].option_name;
+  while (name != NULL) {
+    int length = strlen(name);
+    if (strncmp(option, name, length) == 0) {
+      main_options[i].process(option + length);
+      return true;
+    }
+    i += 1;
+    name = main_options[i].option_name;
+  }
+  return false;
+}
+
+
 // Parse out the command line arguments. Returns -1 if the arguments
 // are incorrect, 0 otherwise.
 static int ParseArguments(int argc,
                           char** argv,
                           CommandLineOptions* vm_options,
                           char** script_name,
                           CommandLineOptions* dart_options) {
   const char* kPrefix = "--";
   const intptr_t kPrefixLen = strlen(kPrefix);
 
   // Skip the binary name.
   int i = 1;
 
   // Parse out the vm options.
   while ((i < argc) && IsValidFlag(argv[i], kPrefix, kPrefixLen)) {
-    if (ProcessPprofOption(argv[i])) {
-      i += 1;
-    } else if (ProcessDebugOption(argv[i])) {
+    if (ProcessMainOptions(argv[i])) {
       i += 1;
     } else {
       vm_options->AddArgument(argv[i]);
       i += 1;
     }
   }
   if (generate_pprof_symbols_filename != NULL) {
     Dart_InitPprofSupport();
   }
 
@@ skipping 126 matching lines @@
 static bool CreateIsolateAndSetup(void* data, char** error) {
   Dart_Isolate isolate = Dart_CreateIsolate(snapshot_buffer, data, error);
   if (isolate == NULL) {
     return false;
   }
 
   Dart_Handle library;
   Dart_EnterScope();
 
   // Load the specified application script into the newly created isolate.
-  library = LoadScript(canonical_script_name);
+  if (script_snapshot_buffer != NULL) {
+    library = Dart_LoadScriptFromSnapshot(script_snapshot_buffer);
+  } else {
+    library = LoadScript(canonical_script_name);
+  }
   if (Dart_IsError(library)) {
     *error = strdup(Dart_GetError(library));
     Dart_ExitScope();
     Dart_ShutdownIsolate();
     return false;
   }
   if (!Dart_IsLibrary(library)) {
     char errbuf[256];
     snprintf(errbuf, sizeof(errbuf),
              "Expected a library when loading script: %s",
              canonical_script_name);
     *error = strdup(errbuf);
     Dart_ExitScope();
     Dart_ShutdownIsolate();
     return false;
   }
-  Builtin::ImportLibrary(library);  // Implicitly import builtin into app.
+  if (script_snapshot_buffer == NULL) {
+    Builtin::ImportLibrary(library);  // Implicitly import builtin into app.
+  }
   if (snapshot_buffer != NULL) {
     // Setup the native resolver as the snapshot does not carry it.
     Builtin::SetNativeResolver();
   }
   Dart_ExitScope();
   return true;
 }
 
 
+static bool CaptureScriptSnapshot() {
+  char* error = NULL;
+  Dart_Handle result;
+
+  // First create an isolate and load up the specified script in it.
+  if (!CreateIsolateAndSetup(NULL, &error)) {
+    fprintf(stderr, "%s\n", error);
+    free(canonical_script_name);
+    free(error);
+    return false;  // Indicates we encountered an error.
+  }
+
+  Dart_EnterScope();
+
+  // Lookup the library of the main script.
+  Dart_Handle script_url = Dart_NewString(canonical_script_name);
+  Dart_Handle library = Dart_LookupLibrary(script_url);
+  if (Dart_IsError(library)) {
+    fprintf(stderr, "%s\n", Dart_GetError(library));
+    Dart_ExitScope();
+    Dart_ShutdownIsolate();
+    free(canonical_script_name);
+    return false;  // Indicates we encountered an error.
+  }
+
+  // Now create the script snapshot and save into a buffer.
+  uint8_t* buffer;
+  intptr_t size;
+  result = Dart_CreateScriptSnapshot(library, &buffer, &size);
+  if (Dart_IsError(result)) {
+    fprintf(stderr, "%s\n", Dart_GetError(result));
+    Dart_ExitScope();
+    Dart_ShutdownIsolate();
+    return false;  // Indicates we encountered an error.
+  }
+
+  // Save the script snapshot as we are about to shutdown isolate.

[Ivan Posva, 2011/12/19 21:32:42]

shutdown the isolate.

[siva, 2011/12/19 23:50:00]

Done.

+  script_snapshot_buffer = reinterpret_cast<uint8_t*>(malloc(size));
+  ASSERT(script_snapshot_buffer != NULL);
+  memmove(script_snapshot_buffer, buffer, size);
+
+  // Shutdown this isolate.
+  Dart_ExitScope();
+  Dart_ShutdownIsolate();
+  return true;
+}
+
+
 static void PrintUsage() {
   fprintf(stderr,
           "dart [<vm-flags>] <dart-script-file> [<dart-options>]\n");
 }
 
 
 static bool HasCompileAll(const CommandLineOptions& options) {
   for (int i = 0; i < options.count(); i++) {
     if (strcmp(options.GetArgument(i), "--compile_all") == 0) {
       return true;
@@ skipping 27 matching lines @@
 
   // Initialize the Dart VM.
   Dart_Initialize(CreateIsolateAndSetup, NULL);
 
   canonical_script_name = File::GetCanonicalPath(script_name);
   if (canonical_script_name == NULL) {
     fprintf(stderr, "Unable to find '%s'\n", script_name);
     return 255;  // Indicates we encountered an error.
   }
 
+  // If application snapshot option is specified, first create the
+  // application snapshot and then load the script using the snapshot
+  // created.
+  if (use_script_snapshot) {
+    if (!CaptureScriptSnapshot()) {
+      return 255;  // Error capturing script snapshot, error already reported.
+    }
+  }
+
   // Call CreateIsolateAndSetup which creates an isolate and loads up
   // the specified application script.
   char* error = NULL;
   if (!CreateIsolateAndSetup(NULL, &error)) {
     fprintf(stderr, "%s\n", error);
     free(canonical_script_name);
     free(error);
+    free(script_snapshot_buffer);
     return 255;  // Indicates we encountered an error.
   }
 
+  free(script_snapshot_buffer);  // Don't need it anymore.
   Dart_Isolate isolate = Dart_CurrentIsolate();
   ASSERT(isolate != NULL);
   Dart_Handle result;
 
   Dart_EnterScope();
 
   if (HasCompileAll(vm_options)) {
     result = Dart_CompileAll();
     if (Dart_IsError(result)) {
       fprintf(stderr, "%s\n", Dart_GetError(result));
@@ skipping 75 matching lines @@
     return 255;  // Indicates we encountered an error.
   }
   free(canonical_script_name);
   Dart_ExitScope();
   // Dump symbol information for the profiler.
   DumpPprofSymbolInfo();
   // Shutdown the isolate.
   Dart_ShutdownIsolate();
   return 0;
 }