Add current rss and embedder name to Observatory

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 <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include "include/dart_api.h"
 #include "include/dart_tools_api.h"
@@ skipping 1338 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 const Dart_EmbedderInformation* GetEmbedderInformationCallback() {
+  static Dart_EmbedderInformation information = {

[zra, 2017/08/10 22:19:50]

The VM could pass in a pointer to a Dart_EmbedderInformation that the embedder
then fills in. That way you don't have to make a global, and worry about
threading issues.

[cbernaschina, 2017/08/10 22:40:28]

That was the first idea, the main problem is related with future expansion of
the structure. It can be used by flutter to send extra information (like the
current skia memory). If we keep the ownership of the structure in the VM if we
add pointers to dynamic arrays it will be responsibility of the VM to free them.

[zra, 2017/08/10 22:49:46]

I'm not sure this simple call is the right API for anything more complicated
than sending a flat structure of const char*s and numbers. I'd expect that
something as specific as Flutter skia memory should rather be implemented as a
service protocol extension.

[cbernaschina, 2017/08/12 00:29:41]

Done.

+    "Dart VM",  // name
+    0,          // current_rss
+    0           // max_rss
+  };
+
+  int64_t max_rss = Process::MaxRSS();
+  int64_t current_rss = Process::CurrentRSS();
+
+  information.max_rss = max_rss >= 0 ? max_rss : 0;
+  information.current_rss = current_rss >= 0 ? current_rss : 0;
+
+  return &information;
+}
+
 static void GenerateAppAOTSnapshot() {
   if (use_blobs) {
     Snapshot::GenerateAppAOTAsBlobs(snapshot_filename);
   } else {
     Snapshot::GenerateAppAOTAsAssembly(snapshot_filename);
   }
 }
 
 #define CHECK_RESULT(result)                                                   \
   if (Dart_IsError(result)) {                                                  \
@@ skipping 488 matching lines @@
   if (error != NULL) {
     EventHandler::Stop();
     Log::PrintErr("VM initialization failed: %s\n", error);
     free(error);
     Platform::Exit(kErrorExitCode);
   }
 
   Dart_SetServiceStreamCallbacks(&ServiceStreamListenCallback,
                                  &ServiceStreamCancelCallback);
   Dart_SetFileModifiedCallback(&FileModifiedCallback);
+  Dart_SetGetEmbedderInformationCallback(&GetEmbedderInformationCallback);
 
   // Run the main isolate until we aren't told to restart.
   while (RunMainIsolate(script_name, &dart_options)) {
     Log::PrintErr("Restarting VM\n");
   }
 
   // Terminate process exit-code handler.
   Process::TerminateExitCodeHandler();
 
   error = Dart_Cleanup();
@@ skipping 27 matching lines @@
   Platform::Exit(Process::GlobalExitCode());
 }
 
 }  // namespace bin
 }  // namespace dart
 
 int main(int argc, char** argv) {
   dart::bin::main(argc, argv);
   UNREACHABLE();
 }