[Tracing] Implement IC statistics in tracing.

src/ic/ic-stats.cc

+// Copyright 2016 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "src/ic/ic-stats.h"
+
+#include "src/flags.h"
+#include "src/objects-inl.h"
+#include "src/tracing/trace-event.h"
+#include "src/tracing/traced-value.h"
+#include "src/v8.h"
+
+namespace v8 {
+namespace internal {
+
+base::LazyInstance<ICStats>::type ICStats::instance_ =
+    LAZY_INSTANCE_INITIALIZER;
+
+ICStats::ICStats() : ic_infos_(MAX_IC_INFO), pos_(0) {
+  base::NoBarrier_Store(&being_used_, 0);
+}
+
+void ICStats::Begin() {
+  if (V8_LIKELY(!FLAG_ic_stats)) return;
+  base::NoBarrier_Store(&being_used_, 1);
+}
+
+void ICStats::End() {
+  if (base::NoBarrier_Load(&being_used_) != 1) return;
+  ++pos_;
+  if (pos_ == MAX_IC_INFO) {
+    Dump();
+  }
+  base::NoBarrier_Store(&being_used_, 0);
+}
+
+void ICStats::Reset() {
+  for (auto ic_info : ic_infos_) {
+    ic_info.Reset();
+  }
+  pos_ = 0;
+}
+
+void ICStats::Dump() {
+  auto value = v8::tracing::TracedValue::Create();
+  value->BeginArray("data");
+  for (int i = 0; i < pos_; ++i) {
+    ic_infos_[i].AppendToTracedValue(value.get());
+  }
+  value->EndArray();
+
+  TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("v8.ic_stats"), "V8.ICStats",
+                       TRACE_EVENT_SCOPE_THREAD, "ic-stats", std::move(value));
+  Reset();
+}
+
+const char* ICStats::GetOrCacheScriptName(Object* obj) {
+  if (script_name_map_.find(obj) != script_name_map_.end()) {
+    return script_name_map_[obj].get();
+  }
+  Script* script = Script::cast(obj);
+  Object* script_name_raw = script->name();
+  if (script_name_raw->IsString()) {
+    String* script_name = String::cast(script->name());

[Camillo Bruni, 2016/12/02 12:12:55]

String::cast(script_name_raw);

[lpy, 2016/12/05 17:49:10]

Done.

+    char* c_script_name =
+        script_name->ToCString(DISALLOW_NULLS, ROBUST_STRING_TRAVERSAL)
+            .release();
+    script_name_map_.insert(
+        std::make_pair(obj, std::unique_ptr<char[]>(c_script_name)));
+    return c_script_name;
+  } else {
+    script_name_map_.insert(
+        std::make_pair(obj, std::unique_ptr<char[]>(nullptr)));
+    return nullptr;
+  }
+  return nullptr;
+}
+
+std::string& ICStats::GetOrCacheFunctionName(JSFunction* function) {
+  if (function_name_map_.find(function) != function_name_map_.end()) {
+    return function_name_map_[function];
+  }
+  SharedFunctionInfo* shared = function->shared();
+  std::string function_name = function->IsOptimized() ? "*" : "~";

[Camillo Bruni, 2016/12/02 12:12:55]

that might be another boolean that could be put no the ICInfo struct WDYT?

[lpy, 2016/12/05 17:49:10]

Done.

+  function_name += shared->DebugName()->ToCString().get();
+  function_name_map_.insert(std::make_pair(function, function_name));
+  return function_name_map_[function];

[Camillo Bruni, 2016/12/02 12:12:55]

return function_name;

[lpy, 2016/12/05 17:49:10]

Done.

+}
+
+ICInfo::ICInfo()
+    : offset(0),
+      script_name(nullptr),
+      line_num(-1),
+      constructor(0),
+      map(nullptr),
+      dict(0),
+      own(0) {}
+
+void ICInfo::Reset() {
+  type.clear();
+  function_name.clear();
+  offset = 0;
+  script_name = nullptr;
+  line_num = -1;
+  constructor = 0;
+  state.clear();
+  map = nullptr;
+  dict = 0;
+  own = 0;
+  instance_type.clear();
+}
+
+void ICInfo::AppendToTracedValue(v8::tracing::TracedValue* value) const {
+  value->BeginDictionary();
+  value->SetString("type", type);
+  if (!function_name.empty()) {
+    value->SetString("functionName", function_name);
+  }
+  if (offset) value->SetInteger("offset", offset);
+  if (script_name) value->SetString("scriptName", script_name);
+  if (line_num != -1) value->SetInteger("lineNum", line_num);
+  if (constructor) value->SetInteger("constructor", constructor);
+  if (!state.empty()) value->SetString("state", state);
+  // TODO(lpy) Find a better solution rather than stringstream.
+  if (map) {
+    std::stringstream ss;
+    ss << map;
+    value->SetString("map", ss.str());

[Camillo Bruni, 2016/12/02 12:12:55]

Can't you just use SetInteger and reinterpet_cast the `void* map` to an int?

[lpy, 2016/12/05 17:49:10]

Done.

+  }
+  if (map) value->SetInteger("dict", dict);
+  if (map) value->SetInteger("own", own);
+  if (!instance_type.empty()) value->SetString("instanceType", instance_type);
+  value->EndDictionary();
+}
+
+}  // namespace internal
+}  // namespace v8