lib,src: remove post-gc event infrastructure

Remove the 'gc' event from the v8 module and remove the supporting
infrastructure from src/.  It gets the axe because:

1. There are currently no users.  It was originally conceived as
   an upstreamed subset of StrongLoop's strong-agent GC metrics,
   but the strong-agent code base has evolved considerably since
   that time and has no use anymore for what is in core.

2. The implementation is not quite sound.  It calls into JS land
   from inside the GC epilog and that is unsafe.  We could fix
   that by delaying the callback until a safe time but because
   there are no users anyway, removing it is all around easier.

PR-URL: https://github.com/iojs/io.js/pull/174
Reviewed-By: Trevor Norris <trev.norris@gmail.com>

1 files changed, 0 insertions, 149 deletions

diff --git a/src/node_v8.cc b/src/node_v8.cc
index fa60bbee4b3..2a080f98c3e 100644
--- a/src/node_v8.cc
+++ b/src/node_v8.cc
@@ -31,153 +31,15 @@ namespace node {
 using v8::Context;
 using v8::Function;
 using v8::FunctionCallbackInfo;
-using v8::GCCallbackFlags;
-using v8::GCType;
 using v8::Handle;
-using v8::HandleScope;
 using v8::HeapStatistics;
 using v8::Isolate;
 using v8::Local;
-using v8::Null;
-using v8::Number;
 using v8::Object;
 using v8::String;
 using v8::Uint32;
 using v8::V8;
 using v8::Value;
-using v8::kGCTypeAll;
-using v8::kGCTypeMarkSweepCompact;
-using v8::kGCTypeScavenge;
-
-
-void Environment::IsolateData::BeforeGarbageCollection(Isolate* isolate,
-                                                       GCType type,
-                                                       GCCallbackFlags flags) {
-  Get(isolate)->BeforeGarbageCollection(type, flags);
-}
-
-
-void Environment::IsolateData::AfterGarbageCollection(Isolate* isolate,
-                                                      GCType type,
-                                                      GCCallbackFlags flags) {
-  Get(isolate)->AfterGarbageCollection(type, flags);
-}
-
-
-void Environment::IsolateData::BeforeGarbageCollection(GCType type,
-                                                       GCCallbackFlags flags) {
-  gc_info_before_ = GCInfo(isolate(), type, flags, uv_hrtime());
-}
-
-
-void Environment::IsolateData::AfterGarbageCollection(GCType type,
-                                                      GCCallbackFlags flags) {
-  gc_info_after_ = GCInfo(isolate(), type, flags, uv_hrtime());
-
-  // The copy upfront and the remove-then-insert is to avoid corrupting the
-  // list when the callback removes itself from it.  QUEUE_FOREACH() is unsafe
-  // when the list is mutated while being walked.
-  ASSERT(QUEUE_EMPTY(&gc_tracker_queue_) == false);
-  QUEUE queue;
-  QUEUE* q = QUEUE_HEAD(&gc_tracker_queue_);
-  QUEUE_SPLIT(&gc_tracker_queue_, q, &queue);
-  while (QUEUE_EMPTY(&queue) == false) {
-    q = QUEUE_HEAD(&queue);
-    QUEUE_REMOVE(q);
-    QUEUE_INSERT_TAIL(&gc_tracker_queue_, q);
-    Environment* env = ContainerOf(&Environment::gc_tracker_queue_, q);
-    env->AfterGarbageCollectionCallback(&gc_info_before_, &gc_info_after_);
-  }
-}
-
-
-void Environment::IsolateData::StartGarbageCollectionTracking(
-    Environment* env) {
-  if (QUEUE_EMPTY(&gc_tracker_queue_)) {
-    isolate()->AddGCPrologueCallback(BeforeGarbageCollection, v8::kGCTypeAll);
-    isolate()->AddGCEpilogueCallback(AfterGarbageCollection, v8::kGCTypeAll);
-  }
-  ASSERT(QUEUE_EMPTY(&env->gc_tracker_queue_) == true);
-  QUEUE_INSERT_TAIL(&gc_tracker_queue_, &env->gc_tracker_queue_);
-}
-
-
-void Environment::IsolateData::StopGarbageCollectionTracking(Environment* env) {
-  ASSERT(QUEUE_EMPTY(&env->gc_tracker_queue_) == false);
-  QUEUE_REMOVE(&env->gc_tracker_queue_);
-  QUEUE_INIT(&env->gc_tracker_queue_);
-  if (QUEUE_EMPTY(&gc_tracker_queue_)) {
-    isolate()->RemoveGCPrologueCallback(BeforeGarbageCollection);
-    isolate()->RemoveGCEpilogueCallback(AfterGarbageCollection);
-  }
-}
-
-
-// Considering a memory constrained environment, creating more objects is less
-// than ideal
-void Environment::AfterGarbageCollectionCallback(const GCInfo* before,
-                                                 const GCInfo* after) {
-  HandleScope handle_scope(isolate());
-  Context::Scope context_scope(context());
-  Local<Value> argv[] = { Object::New(isolate()), Object::New(isolate()) };
-  const GCInfo* infov[] = { before, after };
-  for (unsigned i = 0; i < ARRAY_SIZE(argv); i += 1) {
-    Local<Object> obj = argv[i].As<Object>();
-    const GCInfo* info = infov[i];
-    switch (info->type()) {
-      case kGCTypeScavenge:
-        obj->Set(type_string(), scavenge_string());
-        break;
-      case kGCTypeMarkSweepCompact:
-        obj->Set(type_string(), mark_sweep_compact_string());
-        break;
-      default:
-        UNREACHABLE();
-    }
-    obj->Set(flags_string(), Uint32::NewFromUnsigned(isolate(), info->flags()));
-    obj->Set(timestamp_string(), Number::New(isolate(), info->timestamp()));
-    // TODO(trevnorris): Setting many object properties in C++ is a significant
-    // performance hit. Redo this to pass the results to JS and create/set the
-    // properties there.
-#define V(name)                                                               \
-    do {                                                                      \
-      obj->Set(name ## _string(),                                             \
-               Uint32::NewFromUnsigned(isolate(), info->stats()->name()));    \
-    } while (0)
-    V(total_heap_size);
-    V(total_heap_size_executable);
-    V(total_physical_size);
-    V(used_heap_size);
-    V(heap_size_limit);
-#undef V
-  }
-  MakeCallback(this,
-               Null(isolate()),
-               gc_info_callback_function(),
-               ARRAY_SIZE(argv),
-               argv);
-}
-
-
-void Environment::StartGarbageCollectionTracking(Local<Function> callback) {
-  ASSERT(gc_info_callback_function().IsEmpty() == true);
-  set_gc_info_callback_function(callback);
-  isolate_data()->StartGarbageCollectionTracking(this);
-}
-
-
-void Environment::StopGarbageCollectionTracking() {
-  ASSERT(gc_info_callback_function().IsEmpty() == false);
-  isolate_data()->StopGarbageCollectionTracking(this);
-  set_gc_info_callback_function(Local<Function>());
-}
-
-
-void StartGarbageCollectionTracking(const FunctionCallbackInfo<Value>& args) {
-  CHECK(args[0]->IsFunction() == true);
-  Environment* env = Environment::GetCurrent(args);
-  env->StartGarbageCollectionTracking(args[0].As<Function>());
-}
 
 
 void GetHeapStatistics(const FunctionCallbackInfo<Value>& args) {
@@ -201,11 +63,6 @@ void GetHeapStatistics(const FunctionCallbackInfo<Value>& args) {
 }
 
 
-void StopGarbageCollectionTracking(const FunctionCallbackInfo<Value>& args) {
-  Environment::GetCurrent(args)->StopGarbageCollectionTracking();
-}
-
-
 void SetFlagsFromString(const FunctionCallbackInfo<Value>& args) {
   String::Utf8Value flags(args[0]);
   V8::SetFlagsFromString(*flags, flags.length());
@@ -216,12 +73,6 @@ void InitializeV8Bindings(Handle<Object> target,
                           Handle<Value> unused,
                           Handle<Context> context) {
   Environment* env = Environment::GetCurrent(context);
-  env->SetMethod(target,
-                 "startGarbageCollectionTracking",
-                 StartGarbageCollectionTracking);
-  env->SetMethod(target,
-                 "stopGarbageCollectionTracking",
-                 StopGarbageCollectionTracking);
   env->SetMethod(target, "getHeapStatistics", GetHeapStatistics);
   env->SetMethod(target, "setFlagsFromString", SetFlagsFromString);
 }