Adding 'isolates' argument to LOG to get rid of multiple TLS fetches in profiling.

src/global-handles.cc

 // Copyright 2009 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 92 matching lines @@
     ASSERT(OFFSET_OF(Node, object_) == 0);
     return reinterpret_cast<Node*>(location);
   }
 
   // Returns the handle.
   Handle<Object> handle() { return Handle<Object>(&object_); }
 
   // Make this handle weak.
   void MakeWeak(GlobalHandles* global_handles, void* parameter,
                 WeakReferenceCallback callback) {
-    LOG(HandleEvent("GlobalHandle::MakeWeak", handle().location()));
+    LOG(global_handles->isolate(),
+        HandleEvent("GlobalHandle::MakeWeak", handle().location()));
     ASSERT(state_ != DESTROYED);
     if (state_ != WEAK && !IsNearDeath()) {
       global_handles->number_of_weak_handles_++;
       if (object_->IsJSGlobalObject()) {
         global_handles->number_of_global_object_weak_handles_++;
       }
     }
     state_ = WEAK;
     set_parameter(parameter);
     callback_ = callback;
   }
 
   void ClearWeakness(GlobalHandles* global_handles) {
-    LOG(HandleEvent("GlobalHandle::ClearWeakness", handle().location()));
+    LOG(global_handles->isolate(),
+        HandleEvent("GlobalHandle::ClearWeakness", handle().location()));
     ASSERT(state_ != DESTROYED);
     if (state_ == WEAK || IsNearDeath()) {
       global_handles->number_of_weak_handles_--;
       if (object_->IsJSGlobalObject()) {
         global_handles->number_of_global_object_weak_handles_--;
       }
     }
     state_ = NORMAL;
     set_parameter(NULL);
   }
@@ skipping 24 matching lines @@
     ASSERT(state_ != DESTROYED);
     return parameter_or_next_free_.parameter;
   }
 
   // Returns the callback for this weak handle.
   WeakReferenceCallback callback() { return callback_; }
 
   bool PostGarbageCollectionProcessing(Isolate* isolate,
                                        GlobalHandles* global_handles) {
     if (state_ != Node::PENDING) return false;
-    LOG(HandleEvent("GlobalHandle::Processing", handle().location()));
+    LOG(isolate, HandleEvent("GlobalHandle::Processing", handle().location()));
     WeakReferenceCallback func = callback();
     if (func == NULL) {
       Destroy(global_handles);
       return false;
     }
     void* par = parameter();
     state_ = NEAR_DEATH;
     set_parameter(NULL);
 
     v8::Persistent<v8::Object> object = ToApi<v8::Object>(handle());
@@ skipping 215 matching lines @@
     }
   }
 }
 
 
 void GlobalHandles::IdentifyWeakHandles(WeakSlotCallback f) {
   for (Node* current = head_; current != NULL; current = current->next()) {
     if (current->state_ == Node::WEAK) {
       if (f(&current->object_)) {
         current->state_ = Node::PENDING;
-        LOG(HandleEvent("GlobalHandle::Pending", current->handle().location()));
+        LOG(isolate_,
+            HandleEvent("GlobalHandle::Pending", current->handle().location()));
       }
     }
   }
 }
 
 
 bool GlobalHandles::PostGarbageCollectionProcessing() {
   // Process weak global handle callbacks. This must be done after the
   // GC is completely done, because the callbacks may invoke arbitrary
   // API functions.
@@ skipping 143 matching lines @@
 
 
 void GlobalHandles::RemoveObjectGroups() {
   for (int i = 0; i< object_groups_.length(); i++) {
     delete object_groups_.at(i);
   }
   object_groups_.Clear();
 }
 
 } }  // namespace v8::internal