Remove VM Stats

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_debugger_api.h"
 
 #include "bin/builtin.h"
 #include "bin/dartutils.h"
 #include "bin/dbg_connection.h"
 #include "bin/directory.h"
 #include "bin/eventhandler.h"
 #include "bin/extensions.h"
 #include "bin/file.h"
 #include "bin/isolate_data.h"
 #include "bin/log.h"
 #include "bin/platform.h"
 #include "bin/process.h"
-#include "bin/vmstats_impl.h"
 #include "platform/globals.h"
 
 namespace dart {
 namespace bin {
 
 // 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 snapshot.
 static bool generate_script_snapshot = false;
 static File* snapshot_file = 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;
 
 
 // Global state that indicates whether we should open a connection
 // and listen for a debugger to connect.
 static bool start_debugger = false;
 static const int DEFAULT_DEBUG_PORT = 5858;
 static const char* DEFAULT_DEBUG_IP = "127.0.0.1";
 static const char* debug_ip = DEFAULT_DEBUG_IP;
 static int debug_port = -1;
 
-// Global state that defines the VmStats web server port and root directory.
-static int vmstats_port = -1;
-static const char* vmstats_root = "";
-
 // Value of the --package-root flag.
 // (This pointer points into an argv buffer and does not need to be
 // free'd.)
 static const char* package_root = NULL;
 
 
 // Global flag that is used to indicate that we want to compile all the
 // dart functions and not run anything.
 static bool has_compile_all = false;
 // Global flag that is used to indicate that we want to check function
@@ skipping 100 matching lines @@
     Log::PrintErr("unrecognized --debug option syntax. "
                     "Use --debug[:<port number>]\n");
     return false;
   }
   breakpoint_at = "main";
   start_debugger = true;
   return true;
 }
 
 
-static bool ProcessVmStatsOption(const char* port) {
-  ASSERT(port != NULL);
-  if (*port == '\0') {
-    vmstats_port = 0;  // Dynamically assigned port number.
-  } else {
-    if ((*port == '=') || (*port == ':')) {
-      vmstats_port = atoi(port + 1);
-    }
-  }
-  if (vmstats_port < 0) {
-    Log::PrintErr("unrecognized --stats option syntax. "
-                    "Use --stats[:<port number>]\n");
-    return false;
-  }
-  return true;
-}
-
-
 static bool ProcessPrintScriptOption(const char* arg) {
   ASSERT(arg != NULL);
   if (*arg != '\0') {
     return false;
   }
   has_print_script = true;
   return true;
 }
 
 
-static bool ProcessVmStatsRootOption(const char* arg) {
-  ASSERT(arg != NULL);
-  if (*arg == '\0') {
-    return false;
-  }
-  vmstats_root = arg;
-  return true;
-}
-
-
 static bool ProcessGenScriptSnapshotOption(const char* filename) {
   if (filename != NULL && strlen(filename) != 0) {
     // Ensure that are already running using a full snapshot.
     if (snapshot_buffer == NULL) {
       Log::PrintErr("Script snapshots cannot be generated in this version of"
                     " dart\n");
       return false;
     }
     snapshot_file = File::Open(filename, File::kWriteTruncate);
     if (snapshot_file == NULL) {
@@ skipping 17 matching lines @@
   { "--help", ProcessHelpOption },
   { "-h", ProcessHelpOption },
   { "--verbose", ProcessVerboseOption },
   { "-v", ProcessVerboseOption },
   { "--package-root=", ProcessPackageRootOption },
   // VM specific options to the standalone dart program.
   { "--break-at=", ProcessBreakpointOption },
   { "--compile_all", ProcessCompileAllOption },
   { "--debug", ProcessDebugOption },
   { "--snapshot=", ProcessGenScriptSnapshotOption },
-  { "--stats-root=", ProcessVmStatsRootOption },
-  { "--stats", ProcessVmStatsOption },
   { "--print-script", ProcessPrintScriptOption },
   { "--check-function-fingerprints", ProcessFingerprintedFunctions },
   { NULL, NULL }
 };
 
 
 static bool ProcessMainOptions(const char* option) {
   int i = 0;
   const char* name = main_options[0].option_name;
   int option_length = strlen(option);
@@ skipping 249 matching lines @@
   Dart_ExitScope();
   Dart_ExitIsolate();
   bool retval = Dart_IsolateMakeRunnable(isolate);
   if (!retval) {
     *error = strdup("Invalid isolate state - Unable to make it runnable");
     Dart_EnterIsolate(isolate);
     Dart_ShutdownIsolate();
     return NULL;
   }
 
-  VmStats::AddIsolate(reinterpret_cast<IsolateData*>(data), isolate);
   return isolate;
 }
 
 
 static Dart_Isolate CreateIsolateAndSetup(const char* script_uri,
                                           const char* main,
                                           void* data, char** error) {
   return CreateIsolateAndSetupHelper(script_uri,
                                      main,
                                      new IsolateData(),
@@ skipping 45 matching lines @@
 "  sets a breakpoint at specified location where <location> is one of :\n"
 "  url:<line_num> e.g. test.dart:10\n"
 "  [<class_name>.]<function_name> e.g. B.foo\n"
 "\n"
 "--snapshot=<file_name>\n"
 "  loads Dart script and generates a snapshot in the specified file\n"
 "\n"
 "--print-script\n"
 "  generates Dart source code back and prints it after parsing a Dart script\n"
 "\n"
-"--stats[:<port number>]\n"
-"  enables VM stats service and listens on specified port for HTTP requests\n"
-"  (default port number is dynamically assigned)\n"
-"\n"
-"--stats-root=<path>\n"
-"  where to find static files used by the vmstats application\n"
-"  (used during vmstats plug-in development)\n"
-"\n"
 "The following options are only used for VM development and may\n"
 "be changed in any future version:\n");
     const char* print_flags = "--print_flags";
     Dart_SetVMFlags(1, &print_flags);
   }
 }
 
 
 static Dart_Handle SetBreakpoint(const char* breakpoint_at,
                                  Dart_Handle library) {
@@ skipping 43 matching lines @@
 
   Dart_ExitScope();
   Dart_ShutdownIsolate();
 
   return kErrorExitCode;
 }
 
 
 static void ShutdownIsolate(void* callback_data) {
   IsolateData* isolate_data = reinterpret_cast<IsolateData*>(callback_data);
-  VmStats::RemoveIsolate(isolate_data);
   EventHandler* handler = isolate_data->event_handler;
   if (handler != NULL) handler->Shutdown();
   delete isolate_data;
 }
 
 
 static Dart_Handle GenerateScriptSource() {
   Dart_Handle library_url = Dart_LibraryUrl(Dart_RootLibrary());
   if (Dart_IsError(library_url)) {
     return library_url;
@@ skipping 87 matching lines @@
 
   // Start the debugger wire protocol handler if necessary.
   if (start_debugger) {
     ASSERT(debug_port >= 0);
     bool print_msg = verbose_debug_seen || (debug_port == 0);
     debug_port = DebuggerConnectionHandler::StartHandler(debug_ip, debug_port);
     if (print_msg) {
       Log::Print("Debugger listening on port %d\n", debug_port);
     }
   }
-  VmStats::Start(vmstats_port, vmstats_root, verbose_debug_seen);
 
   // Call CreateIsolateAndSetup which creates an isolate and loads up
   // the specified application script.
   char* error = NULL;
   char* isolate_name = BuildIsolateName(script_name, "main");
   Dart_Isolate isolate = CreateIsolateAndSetupHelper(script_name,
                                                      "main",
                                                      new IsolateData(),
                                                      &error);
   if (isolate == NULL) {
@@ skipping 81 matching lines @@
 
       // Keep handling messages until the last active receive port is closed.
       result = Dart_RunLoop();
       if (Dart_IsError(result)) {
         return ErrorExit("%s\n", Dart_GetError(result));
       }
     }
   }
 
   Dart_ExitScope();
-  if (vmstats_port >= 0) {
-    VmStats::Stop();
-  }
   // Shutdown the isolate.
   Dart_ShutdownIsolate();
   // Terminate process exit-code handler.
   Process::TerminateExitCodeHandler();
   // Free copied argument strings if converted.
   if (argv_converted) {
     for (int i = 0; i < argc; i++) free(argv[i]);
   }
 
   return Process::GlobalExitCode();
 }
 
 }  // namespace bin
 }  // namespace dart
 
 int main(int argc, char** argv) {
   return dart::bin::main(argc, argv);
 }