[Isolates] Merge 6700:7030 from bleeding_edge to isolates.

src/runtime-profiler.cc

 // Copyright 2010 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 17 matching lines @@
 #include "v8.h"
 
 #include "runtime-profiler.h"
 
 #include "assembler.h"
 #include "code-stubs.h"
 #include "compilation-cache.h"
 #include "deoptimizer.h"
 #include "execution.h"
 #include "global-handles.h"
+#include "mark-compact.h"
 #include "platform.h"
 #include "scopeinfo.h"
 
 namespace v8 {
 namespace internal {
 
 
 class PendingListNode : public Malloced {
  public:
   explicit PendingListNode(JSFunction* function);
@@ skipping 52 matching lines @@
   function_= Handle<Object>::null();
 }
 
 
 void PendingListNode::WeakCallback(v8::Persistent<v8::Value>, void* data) {
   reinterpret_cast<PendingListNode*>(data)->Destroy();
 }
 
 
 static bool IsOptimizable(JSFunction* function) {
-  if (function->GetHeap()->InNewSpace(function)) return false;
   Code* code = function->code();
   return code->kind() == Code::FUNCTION && code->optimizable();
 }
 
 
 Atomic32 RuntimeProfiler::state_ = 0;
 // TODO(isolates): Create the semaphore lazily and clean it up when no
 // longer required.
 #ifdef ENABLE_LOGGING_AND_PROFILING
 Semaphore* RuntimeProfiler::semaphore_ = OS::CreateSemaphore(0);
@@ skipping 84 matching lines @@
   }
 }
 
 
 void RuntimeProfiler::ClearSampleBuffer() {
   memset(sampler_window_, 0, sizeof(sampler_window_));
   memset(sampler_window_weight_, 0, sizeof(sampler_window_weight_));
 }
 
 
-void RuntimeProfiler::ClearSampleBufferNewSpaceEntries() {
-  for (int i = 0; i < kSamplerWindowSize; i++) {
-    if (isolate_->heap()->InNewSpace(sampler_window_[i])) {
-      sampler_window_[i] = NULL;
-      sampler_window_weight_[i] = 0;
-    }
-  }
-}
-
-
 int RuntimeProfiler::LookupSample(JSFunction* function) {
   int weight = 0;
   for (int i = 0; i < kSamplerWindowSize; i++) {
     Object* sample = sampler_window_[i];
     if (sample != NULL) {
       if (function == sample) {
         weight += sampler_window_weight_[i];
       }
     }
   }
@@ skipping 130 matching lines @@
   // Record state sample.
   SamplerState state = IsSomeIsolateInJS()
       ? IN_JS_STATE
       : IN_NON_JS_STATE;
   UpdateStateRatio(state);
   isolate_->stack_guard()->RequestRuntimeProfilerTick();
 #endif
 }
 
 
-void RuntimeProfiler::MarkCompactPrologue(bool is_compacting) {
-  if (is_compacting) {
-    // Clear all samples before mark-sweep-compact because every
-    // function might move.
-    ClearSampleBuffer();
-  } else {
-    // Clear only new space entries on mark-sweep since none of the
-    // old-space functions will move.
-    ClearSampleBufferNewSpaceEntries();
-  }
-}
-
-
 void RuntimeProfiler::Setup() {
   ClearSampleBuffer();
   // If the ticker hasn't already started, make sure to do so to get
   // the ticks for the runtime profiler.
   if (IsEnabled()) isolate_->logger()->EnsureTickerStarted();
 }
 
 
 void RuntimeProfiler::Reset() {
   sampler_threshold_ = kSamplerThresholdInit;
   sampler_threshold_size_factor_ = kSamplerThresholdSizeFactorInit;
   sampler_ticks_until_threshold_adjustment_ =
       kSamplerTicksBetweenThresholdAdjustment;
 }
 
 
 void RuntimeProfiler::TearDown() {
   // Nothing to do.
 }
 
 
-Object** RuntimeProfiler::SamplerWindowAddress() {
-  return sampler_window_;
-}
-
-
 int RuntimeProfiler::SamplerWindowSize() {
   return kSamplerWindowSize;
 }
 
 
+// Update the pointers in the sampler window after a GC.
+void RuntimeProfiler::UpdateSamplesAfterScavenge() {
+  for (int i = 0; i < kSamplerWindowSize; i++) {
+    Object* function = sampler_window_[i];
+    if (function != NULL && isolate_->heap()->InNewSpace(function)) {
+      MapWord map_word = HeapObject::cast(function)->map_word();
+      if (map_word.IsForwardingAddress()) {
+        sampler_window_[i] = map_word.ToForwardingAddress();
+      } else {
+        sampler_window_[i] = NULL;
+      }
+    }
+  }
+}
+
+
 void RuntimeProfiler::HandleWakeUp(Isolate* isolate) {
 #ifdef ENABLE_LOGGING_AND_PROFILING
   // The profiler thread must still be waiting.
   ASSERT(NoBarrier_Load(&state_) >= 0);
   // In IsolateEnteredJS we have already incremented the counter and
   // undid the decrement done by the profiler thread. Increment again
   // to get the right count of active isolates.
   NoBarrier_AtomicIncrement(&state_, 1);
   semaphore_->Signal();
   isolate->ResetEagerOptimizingData();
@@ skipping 17 matching lines @@
 }
 
 
 void RuntimeProfiler::WakeUpRuntimeProfilerThreadBeforeShutdown() {
 #ifdef ENABLE_LOGGING_AND_PROFILING
   semaphore_->Signal();
 #endif
 }
 
 
+void RuntimeProfiler::RemoveDeadSamples() {
+  for (int i = 0; i < kSamplerWindowSize; i++) {
+    Object* function = sampler_window_[i];
+    if (function != NULL && !HeapObject::cast(function)->IsMarked()) {
+      sampler_window_[i] = NULL;
+    }
+  }
+}
+
+
+void RuntimeProfiler::UpdateSamplesAfterCompact(ObjectVisitor* visitor) {
+  for (int i = 0; i < kSamplerWindowSize; i++) {
+    visitor->VisitPointer(&sampler_window_[i]);
+  }
+}
+
+
 bool RuntimeProfilerRateLimiter::SuspendIfNecessary() {
 #ifdef ENABLE_LOGGING_AND_PROFILING
   static const int kNonJSTicksThreshold = 100;
   if (RuntimeProfiler::IsSomeIsolateInJS()) {
     non_js_ticks_ = 0;
   } else {
     if (non_js_ticks_ < kNonJSTicksThreshold) {
       ++non_js_ticks_;
     } else {
       return RuntimeProfiler::WaitForSomeIsolateToEnterJS();
     }
   }
 #endif
   return false;
 }
 
 
 } }  // namespace v8::internal