Added ctrl-\ command that dumps isolate stacks to dart binary.

runtime/bin/vmstats_impl.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.
 
 #include "bin/vmstats_impl.h"
 
 #include "bin/file.h"
 #include "bin/log.h"
 #include "bin/platform.h"
 #include "bin/resources.h"
@@ skipping 15 matching lines @@
 dart::Monitor* VmStats::instance_monitor_;
 dart::Mutex* VmStatusService::mutex_;
 
 
 void VmStats::Start(int port, const char* root_dir) {
   if (instance_ != NULL) {
     FATAL("VmStats already started.");
   }
   instance_ = new VmStats();
   instance_monitor_ = new dart::Monitor();
+  Initialize();
+
+  if (port != 0) {
+    StartServer(port, root_dir);
+  }
+}
+
+
+void VmStats::StartServer(int port, const char* root_dir) {
   VmStatusService::InitOnce();
   Socket::Initialize();
 
   if (root_dir != NULL) {
     instance_->root_directory_ = root_dir;
   }
 
   // TODO(tball): allow host to be specified.
   char* host = const_cast<char*>(DEFAULT_HOST);
   OSError* os_error;
@@ skipping 15 matching lines @@
 
   MonitorLocker ml(instance_monitor_);
   instance_->running_ = true;
   int err = dart::Thread::Start(WebServer, address);
   if (err != 0) {
     Log::PrintErr("Failed starting VmStats thread: %d\n", err);
     Shutdown();
   }
 }
 
-
 void VmStats::Stop() {
   ASSERT(instance_ != NULL);
   MonitorLocker ml(instance_monitor_);
   instance_->running_ = false;
 }
 
 
 void VmStats::Shutdown() {
   ASSERT(instance_ != NULL);
   MonitorLocker ml(instance_monitor_);
@@ skipping 238 matching lines @@
       }
       first = false;
       free(status);
     }
   }
   text.AddString("\n]\n}\n");
   return strdup(text.buf());
 }
 
 
+// Platform-independent version of strndup(), which Windows doesn't have.
+static char* Strndup(const char* s, intptr_t len) {
+  char* dup = reinterpret_cast<char*>(malloc(len + 1));
+  strncpy(dup, s, len);
+  dup[len] = '\0';
+  return dup;

[siva, 2013/04/04 00:47:15]

Please see comment in other CL about moving this as strndup
to platform/c99_support_win.h

[Tom Ball, 2013/04/04 20:05:53]

Done.

+}
+
+
+// Advance the scanner to the value token of a specified name-value pair.
+void SeekNamedValue(const char* name, dart::JSONScanner* scanner) {
+  while (!scanner->EOM()) {
+    scanner->Scan();
+    if (scanner->IsStringLiteral(name)) {
+      scanner->Scan();
+      ASSERT(scanner->CurrentToken() == dart::JSONScanner::TokenColon);
+      scanner->Scan();
+     return;
+    }
+  }
+}
+
+void VmStats::DumpStack() {
+  Log::Print("Isolate dump:\n");
+  IsolateTable::iterator itr;
+  for (itr = instance_->isolate_table_.begin();
+       itr != instance_->isolate_table_.end(); ++itr) {

[siva, 2013/04/04 00:47:15]

This map could potentially be changing while this function
is iterating through it right.

[Tom Ball, 2013/04/04 20:05:53]

Right -- I added a MutexLocker.

+    Dart_Isolate isolate = itr->second;
+
+    // Print isolate name and details.
+    static char buffer[512];
+    snprintf(buffer, sizeof(buffer),
+             "/isolate/0x%"Px, reinterpret_cast<intptr_t>(isolate));
+    char* isolate_details = VmStatusService::GetVmStatus(buffer);
+    if (isolate_details != NULL) {
+      dart::JSONScanner scanner(isolate_details);
+      SeekNamedValue("name", &scanner);

[siva, 2013/04/04 00:47:15]

How come you are not using the JSONReader class which
has a Seek(const char* name) method to seek out name/value
pairs. Would be more efficient than repeated scanning
starting from the first again.

[Tom Ball, 2013/04/04 20:05:53]

Its Seek is limited to top-level name-value pairs, so any data inside an array
or object is skipped. I debated enhancing JSONReader, but it would have doubled
its size for this one small client.

+      char* name = Strndup(scanner.TokenChars(), scanner.TokenLen());
+      SeekNamedValue("port", &scanner);
+      char* port = Strndup(scanner.TokenChars(), scanner.TokenLen());
+      Log::Print("\"%s\" port=%s\n", name, port);
+      free(isolate_details);
+      free(port);
+      free(name);
+    }
+
+    // Print stack trace.
+    snprintf(buffer, sizeof(buffer),
+             "/isolate/0x%"Px"/stacktrace",
+             reinterpret_cast<intptr_t>(isolate));
+    char* trace = VmStatusService::GetVmStatus(buffer);
+    if (trace != NULL) {
+      dart::JSONScanner scanner(trace);
+      SeekNamedValue("url", &scanner);
+      char* url = Strndup(scanner.TokenChars(), scanner.TokenLen());
+      SeekNamedValue("line", &scanner);
+      char* line = Strndup(scanner.TokenChars(), scanner.TokenLen());
+      SeekNamedValue("function", &scanner);
+      char* function = Strndup(scanner.TokenChars(), scanner.TokenLen());
+      Log::Print("  at %s(%s:%s)\n", function, url, line);
+      free(trace);
+      free(url);
+      free(line);
+      free(function);
+    }
+  }
+}
+
+
 // Global static pointer used to ensure a single instance of the class.
 VmStatusService* VmStatusService::instance_ = NULL;
 
 
 void VmStatusService::InitOnce() {
   ASSERT(VmStatusService::instance_ == NULL);
   VmStatusService::instance_ = new VmStatusService();
   VmStatusService::mutex_ = new dart::Mutex();
 
   // Register built-in status plug-ins. RegisterPlugin is not used because
@@ skipping 25 matching lines @@
   VmStatusPlugin* plugin = instance_->registered_plugin_list_;
   while (plugin != NULL) {
     char* result = (plugin->callback())(request);
     if (result != NULL) {
       return result;
     }
     plugin = plugin->next();
   }
   return NULL;
 }