Expose allocation tracing over service protocol

runtime/vm/service.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 "vm/service.h"
 
 #include "include/dart_api.h"
 #include "platform/globals.h"
 
 #include "vm/compiler.h"
@@ skipping 241 matching lines @@
   // Skip the dash.
   s++;
   // Extract the PC.
   if (!GetUnsignedIntegerId(s, address, 16)) {
     return false;
   }
   return true;
 }
 
 
+// Verifies that |s| begins with |prefix| and then calls |GetIntegerId| on
+// the remainder of |s|.
+static bool GetPrefixedIntegerId(const char* s,
+                                 const char* prefix,
+                                 intptr_t* service_id) {
+  if (s == NULL) {
+    return false;
+  }
+  ASSERT(prefix != NULL);
+  const intptr_t kInputLen = strlen(s);
+  const intptr_t kPrefixLen = strlen(prefix);
+  ASSERT(kPrefixLen > 0);
+  if (kInputLen <= kPrefixLen) {
+    return false;
+  }
+  if (strncmp(s, prefix, kPrefixLen) != 0) {
+    return false;
+  }
+  // Prefix satisfied. Move forward.
+  s += kPrefixLen;
+  // Attempt to read integer id.
+  return GetIntegerId(s, service_id);
+}
+
+
+static bool IsValidClassId(Isolate* isolate, intptr_t cid) {
+  ASSERT(isolate != NULL);
+  ClassTable* class_table = isolate->class_table();
+  ASSERT(class_table != NULL);
+  return class_table->IsValidIndex(cid) && class_table->HasValidClassAt(cid);
+}
+
+
+static RawClass* GetClassForId(Isolate* isolate, intptr_t cid) {
+  ASSERT(isolate == Isolate::Current());
+  ASSERT(isolate != NULL);
+  ClassTable* class_table = isolate->class_table();
+  ASSERT(class_table != NULL);
+  return class_table->At(cid);
+}
+
+
 // TODO(johnmccutchan): Split into separate file and write unit tests.
 class MethodParameter {
  public:
   MethodParameter(const char* name, bool required)
       : name_(name), required_(required) {
   }
 
   virtual ~MethodParameter() { }
 
   virtual bool Validate(const char* value) const {
@@ skipping 63 matching lines @@
     }
     for (const char* cp = value; *cp != '\0'; cp++) {
       if (*cp < '0' || *cp > '9') {
         return false;
       }
     }
     return true;
   }
 
   static intptr_t Parse(const char* value) {
+    if (value == NULL) {
+      return -1;
+    }
     char* end_ptr = NULL;
     uintptr_t result = strtoul(value, &end_ptr, 10);
     ASSERT(*end_ptr == '\0');  // Parsed full string
     return result;
   }
 };
 
 
 class IdParameter : public MethodParameter {
  public:
@@ skipping 1874 matching lines @@
 };
 
 
 static const MethodParameter* get_cpu_profile_params[] = {
   ISOLATE_PARAMETER,
   new EnumParameter("tags", true, tags_enum_names),
   NULL,
 };
 
 
+// TODO(johnmccutchan): Rename this to GetCpuSamples.
 static bool GetCpuProfile(Isolate* isolate, JSONStream* js) {
   Profile::TagOrder tag_order =
       EnumMapper(js->LookupParam("tags"), tags_enum_names, tags_enum_values);
   ProfilerService::PrintJSON(js, tag_order);
   return true;
 }
 
 
+static const MethodParameter* get_allocation_samples_params[] = {
+  ISOLATE_PARAMETER,
+  new EnumParameter("tags", true, tags_enum_names),
+  new IdParameter("classId", false),
+  NULL,
+};
+
+
+static bool GetAllocationSamples(Isolate* isolate, JSONStream* js) {
+  Profile::TagOrder tag_order =
+      EnumMapper(js->LookupParam("tags"), tags_enum_names, tags_enum_values);
+  const char* class_id = js->LookupParam("classId");
+  intptr_t cid = -1;
+  GetPrefixedIntegerId(class_id, "classes/", &cid);
+  if (IsValidClassId(isolate, cid)) {
+    const Class& cls = Class::Handle(GetClassForId(isolate, cid));
+    ProfilerService::PrintAllocationJSON(js, tag_order, cls);
+  } else {
+    PrintInvalidParamError(js, "classId");
+  }
+  return true;
+}
+
+
 static const MethodParameter* clear_cpu_profile_params[] = {
   ISOLATE_PARAMETER,
   NULL,
 };
 
 
 static bool ClearCpuProfile(Isolate* isolate, JSONStream* js) {
   ProfilerService::ClearSamples();
   PrintSuccess(js);
   return true;
@@ skipping 487 matching lines @@
   isolate->set_debugger_name(js->LookupParam("name"));
   if (Service::NeedsIsolateEvents()) {
     ServiceEvent event(isolate, ServiceEvent::kIsolateUpdate);
     Service::HandleEvent(&event);
   }
   PrintSuccess(js);
   return true;
 }
 
 
+static const MethodParameter* set_trace_class_allocation_params[] = {
+  ISOLATE_PARAMETER,
+  new IdParameter("classId", true),
+  new BoolParameter("enable", true),
+  NULL,
+};
+
+
+static bool SetTraceClassAllocation(Isolate* isolate, JSONStream* js) {
+  const char* class_id = js->LookupParam("classId");
+  const bool enable = BoolParameter::Parse(js->LookupParam("enable"));
+  intptr_t cid = -1;
+  GetPrefixedIntegerId(class_id, "classes/", &cid);
+  if (!IsValidClassId(isolate, cid)) {
+    PrintInvalidParamError(js, "classId");
+    return true;
+  }
+  const Class& cls = Class::Handle(GetClassForId(isolate, cid));
+  ASSERT(!cls.IsNull());
+  cls.SetTraceAllocation(enable);
+  PrintSuccess(js);
+  return true;
+}
+
+
 static ServiceMethodDescriptor service_methods_[] = {
   { "_dumpIdZone", DumpIdZone, NULL },
   { "_echo", Echo,
     NULL },
   { "_respondWithMalformedJson", RespondWithMalformedJson,
     NULL },
   { "_respondWithMalformedObject", RespondWithMalformedObject,
     NULL },
   { "_triggerEchoEvent", TriggerEchoEvent,
     NULL },
   { "addBreakpoint", AddBreakpoint,
     add_breakpoint_params },
   { "addBreakpointAtEntry", AddBreakpointAtEntry,
     add_breakpoint_at_entry_params },
   { "_addBreakpointAtActivation", AddBreakpointAtActivation,
     add_breakpoint_at_activation_params },
   { "_clearCpuProfile", ClearCpuProfile,
     clear_cpu_profile_params },
   { "evaluate", Evaluate,
     evaluate_params },
   { "evaluateInFrame", EvaluateInFrame,
     evaluate_in_frame_params },
   { "_getAllocationProfile", GetAllocationProfile,
     get_allocation_profile_params },
+  { "_getAllocationSamples", GetAllocationSamples,
+      get_allocation_samples_params },
   { "_getCallSiteData", GetCallSiteData,
     get_call_site_data_params },
   { "getClassList", GetClassList,
     get_class_list_params },
   { "_getCoverage", GetCoverage,
     get_coverage_params },
   { "_getCpuProfile", GetCpuProfile,
     get_cpu_profile_params },
   { "getFlagList", GetFlagList,
     get_flag_list_params },
@@ skipping 42 matching lines @@
   { "_requestHeapSnapshot", RequestHeapSnapshot,
     request_heap_snapshot_params },
   { "_setExceptionPauseInfo", SetExceptionPauseInfo,
     set_exception_pause_info_params },
   { "_setFlag", SetFlag,
     set_flags_params },
   { "setLibraryDebuggable", SetLibraryDebuggable,
     set_library_debuggable_params },
   { "setName", SetName,
     set_name_params },
+  { "_setTraceClassAllocation", SetTraceClassAllocation,
+    set_trace_class_allocation_params },
 };
 
 
 ServiceMethodDescriptor* FindMethod(const char* method_name) {
   intptr_t num_methods = sizeof(service_methods_) /
                          sizeof(service_methods_[0]);
   for (intptr_t i = 0; i < num_methods; i++) {
     ServiceMethodDescriptor& method = service_methods_[i];
     if (strcmp(method_name, method.name) == 0) {
       return &method;
     }
   }
   return NULL;
 }
 
 
 }  // namespace dart