Initial memory use status page

pkg/analysis_server/lib/src/status/get_handler.dart

 // Copyright (c) 2014, 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.
 
 library analysis_server.src.status.get_handler;
 
 import 'dart:collection';
 import 'dart:convert';
 import 'dart:io';
 import 'dart:math';
 
 import 'package:analysis_server/plugin/protocol/protocol.dart' hide Element;
 import 'package:analysis_server/src/analysis_server.dart';
 import 'package:analysis_server/src/domain_completion.dart';
 import 'package:analysis_server/src/domain_diagnostic.dart';
 import 'package:analysis_server/src/domain_execution.dart';
 import 'package:analysis_server/src/operation/operation.dart';
 import 'package:analysis_server/src/operation/operation_analysis.dart';
 import 'package:analysis_server/src/operation/operation_queue.dart';
 import 'package:analysis_server/src/services/completion/completion_performance.dart';
 import 'package:analysis_server/src/socket_server.dart';
 import 'package:analysis_server/src/status/ast_writer.dart';
 import 'package:analysis_server/src/status/element_writer.dart';
+import 'package:analysis_server/src/status/memory_use.dart';
 import 'package:analysis_server/src/status/validator.dart';
 import 'package:analysis_server/src/utilities/average.dart';
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/visitor.dart';
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/source/embedder.dart';
 import 'package:analyzer/source/error_processor.dart';
 import 'package:analyzer/source/sdk_ext.dart';
 import 'package:analyzer/src/context/cache.dart';
@@ skipping 217 matching lines @@
    * The path used to request diagnostic information.
    */
   static const String DIAGNOSTIC_PATH = '/diagnostic';
 
   /**
    * The path used to request information about a element model.
    */
   static const String ELEMENT_PATH = '/element';
 
   /**
+   * The path used to request an analysis of the memory use of the analyzer.
+   */
+  static const String MEMORY_USE_PATH = '/memoryUse';
+
+  /**
    * The path used to request an overlay contents.
    */
   static const String OVERLAY_PATH = '/overlay';
 
   /**
    * The path used to request overlays information.
    */
   static const String OVERLAYS_PATH = '/overlays';
 
   /**
@@ skipping 112 matching lines @@
     } else if (path == CONTEXT_DIAGNOSTICS_PATH) {
       _returnContextDiagnostics(request);
     } else if (path == CONTEXT_VALIDATION_DIAGNOSTICS_PATH) {
       _returnContextValidationDiagnostics(request);
     } else if (path == CONTEXT_PATH) {
       _returnContextInfo(request);
     } else if (path == DIAGNOSTIC_PATH) {
       _returnDiagnosticInfo(request);
     } else if (path == ELEMENT_PATH) {
       _returnElement(request);
+    } else if (path == MEMORY_USE_PATH) {
+      _returnMemoryUsage(request);
     } else if (path == OVERLAY_PATH) {
       _returnOverlayContents(request);
     } else if (path == OVERLAYS_PATH) {
       _returnOverlaysInfo(request);
     } else {
       _returnUnknownRequest(request);
     }
   }
 
   /**
@@ skipping 1234 matching lines @@
 
   void _returnFailure(HttpRequest request, String message) {
     _writeResponse(request, (StringBuffer buffer) {
       _writePage(buffer, 'Analysis Server - Failure', [],
           (StringBuffer buffer) {
         buffer.write(HTML_ESCAPE.convert(message));
       });
     });
   }
 
+  void _returnMemoryUsage(HttpRequest request) {
+    _writeResponse(request, (StringBuffer buffer) {
+      _writePage(buffer, 'Analysis Server - Memory Use', [],
+          (StringBuffer buffer) {
+        AnalysisServer server = _server.analysisServer;
+        MemoryUseData data = new MemoryUseData();
+        data.processAnalysisServer(server);
+        Map<Type, HashSet> instances = data.instances;
+        List<Type> classNames = instances.keys.toList();

[scheglov, 2016/07/11 15:27:49]

These are not names, but types.
Just in case if this is an incidental misnomer.

[Brian Wilkerson, 2016/07/11 17:26:36]

It was accidental, thanks. Done.

+        classNames.sort((Type left, Type right) =>
+            left.toString().compareTo(right.toString()));
+
+        buffer.write('<h3>Instance Counts (reachable from contexts)</h3>');
+        buffer.write('<table>');
+        _writeRow(buffer, ['Count', 'Class name'], header: true);
+        classNames.forEach((Type type) {
+          _writeRow(buffer, [instances[type].length, type],
+              classes: ['right', null]);
+        });
+        buffer.write('</table>');
+
+        void writeCountMap(String title, Map<Type, int> counts) {
+          List<Type> classNames = counts.keys.toList();
+          classNames.sort((Type left, Type right) =>
+              left.toString().compareTo(right.toString()));
+
+          buffer.write('<h3>$title</h3>');
+          buffer.write('<table>');
+          _writeRow(buffer, ['Count', 'Class name'], header: true);
+          classNames.forEach((Type type) {
+            _writeRow(buffer, [counts[type], type], classes: ['right', null]);
+          });
+          buffer.write('</table>');
+        }
+        writeCountMap('Directly Held AST Nodes', data.directNodeCounts);
+        writeCountMap('Indirectly Held AST Nodes', data.indirectNodeCounts);
+        writeCountMap('Directly Held Elements', data.elementCounts);
+
+        buffer.write('<h3>Other Data</h3>');
+        buffer.write('<p>');
+        buffer.write(data.uniqueTargetedResults.length);
+        buffer.write(' non-equal TargetedResults</p>');
+        buffer.write('<p>');
+        buffer.write(data.uniqueLSUs.length);
+        buffer.write(' non-equal LibrarySpecificUnits</p>');
+      });
+    });
+  }
+
   void _returnOverlayContents(HttpRequest request) {
     String path = request.requestedUri.queryParameters[PATH_PARAM];
     if (path == null) {
       return _returnFailure(request, 'Query parameter $PATH_PARAM required');
     }
     String contents = _overlayContents[path];
 
     _writeResponse(request, (StringBuffer buffer) {
       _writePage(buffer, 'Analysis Server - Overlay', [],
           (StringBuffer buffer) {
@@ skipping 564 matching lines @@
   /**
    * Write to the given [buffer] a representation of the given [map] of strings
    * to strings.
    */
   void _writeMapOfStringToString(StringBuffer buffer, Map<String, String> map) {
     List<String> keys = map.keys.toList();
     keys.sort();
     int length = keys.length;
     buffer.write('{');
     for (int i = 0; i < length; i++) {
+      buffer.write('<br>');
       String key = keys[i];
       if (i > 0) {
         buffer.write(', ');
       }
       buffer.write(key);
       buffer.write(' = ');
       buffer.write(map[key]);
     }
-    buffer.write('}');
+    buffer.write('<br>}');
   }
 
   /**
    * Write a representation of an analysis option with the given [name] and
    * [value] to the given [buffer]. The option should be separated from other
    * options unless the [last] flag is true, indicating that this is the last
    * option in the list of options.
    */
   void _writeOption(StringBuffer buffer, String name, Object value,
       {bool last: false}) {
@@ skipping 32 matching lines @@
     buffer.write(
         'h3 {background-color: #DDDDDD; margin-top: 0em; margin-bottom: 0em;}');
     buffer.write('p {margin-top: 0.5em; margin-bottom: 0.5em;}');
     buffer.write(
         'p.commentary {margin-top: 1em; margin-bottom: 1em; margin-left: 2em; font-style: italic;}');
 //    response.write('span.error {text-decoration-line: underline; text-decoration-color: red; text-decoration-style: wavy;}');
     buffer.write(
         'table.column {border: 0px solid black; width: 100%; table-layout: fixed;}');
     buffer.write('td.column {vertical-align: top; width: 50%;}');
     buffer.write('td.right {text-align: right;}');
+    buffer.write('th {text-align: left;}');
     buffer.write('</style>');
     buffer.write('</head>');
 
     buffer.write('<body>');
     buffer.write(
         '<h2>$title <small><small>(as of $time on $date)</small></small></h2>');
     if (subtitles != null && subtitles.isNotEmpty) {
       buffer.write('<blockquote>');
       bool first = true;
       for (String subtitle in subtitles) {
@@ skipping 138 matching lines @@
       buffer.write('</p>');
 
       buffer.write('<p><b>Performance Data</b></p>');
       buffer.write('<p>');
       buffer.write(makeLink(
           COMMUNICATION_PERFORMANCE_PATH, {}, 'Communication performance'));
       buffer.write('</p>');
       buffer.write('<p>');
       buffer.write(makeLink(DIAGNOSTIC_PATH, {}, 'General diagnostics'));
       buffer.write('</p>');
+      buffer.write('<p>');
+      buffer.write(makeLink(MEMORY_USE_PATH, {}, 'Memory usage'));
+      buffer.write(' <small>(long running)</small></p>');
     }, (StringBuffer buffer) {
       _writeSubscriptionList(buffer, ServerService.VALUES, services);
     });
     return analysisServer != null;
   }
 
   /**
    * Write a representation of the given [stackTrace] to the given [buffer].
    */
   void _writeStackTrace(StringBuffer buffer, StackTrace stackTrace) {
@@ skipping 187 matching lines @@
    */
   static String makeLink(
       String path, Map<String, String> params, String innerHtml,
       [bool hasError = false]) {
     Uri uri = new Uri(path: path, queryParameters: params);
     String href = HTML_ESCAPE.convert(uri.toString());
     String classAttribute = hasError ? ' class="error"' : '';
     return '<a href="$href"$classAttribute>$innerHtml</a>';
   }
 }