Move most of the implementation of AdjustAmountOfExternalMemory to v8.h

src/heap-inl.h

 // Copyright 2012 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.
 
 #ifndef V8_HEAP_INL_H_
 #define V8_HEAP_INL_H_
 
 #include <cmath>
 
 #include "src/heap.h"
@@ skipping 509 matching lines @@
 
 bool Heap::CollectGarbage(AllocationSpace space,
                           const char* gc_reason,
                           const v8::GCCallbackFlags callbackFlags) {
   const char* collector_reason = NULL;
   GarbageCollector collector = SelectGarbageCollector(space, &collector_reason);
   return CollectGarbage(collector, gc_reason, collector_reason, callbackFlags);
 }
 
 
 int64_t Heap::AdjustAmountOfExternalAllocatedMemory(

[Hannes Payer (out of office), 2014/06/04 12:18:30]

Why don't we get rid of this method? It seems like we can completely inline this
method in v8.h except for the call to CollectGarbage which is the slow path.

     int64_t change_in_bytes) {
   ASSERT(HasBeenSetUp());
   int64_t amount = amount_of_external_allocated_memory_ + change_in_bytes;
   if (change_in_bytes > 0) {
-    // Avoid overflow.

[jochen (gone - plz use gerrit), 2014/06/04 11:53:07]

note that signed overflow is undefined, so these checks all don't make sense

-    if (amount > amount_of_external_allocated_memory_) {
-      amount_of_external_allocated_memory_ = amount;
-    } else {
-      // Give up and reset the counters in case of an overflow.
-      amount_of_external_allocated_memory_ = 0;
-      amount_of_external_allocated_memory_at_last_global_gc_ = 0;
-    }
+    amount_of_external_allocated_memory_ = amount;
     int64_t amount_since_last_global_gc = PromotedExternalMemorySize();
-    if (amount_since_last_global_gc > external_allocation_limit_) {
+    if (amount_since_last_global_gc > Internals::kExternalAllocationLimit) {
       CollectAllGarbage(kNoGCFlags, "external memory allocation limit reached");
     }
   } else {
-    // Avoid underflow.
-    if (amount >= 0) {
-      amount_of_external_allocated_memory_ = amount;
-    } else {
-      // Give up and reset the counters in case of an underflow.
-      amount_of_external_allocated_memory_ = 0;
-      amount_of_external_allocated_memory_at_last_global_gc_ = 0;
-    }
+    amount_of_external_allocated_memory_ = amount;
   }
   if (FLAG_trace_external_memory) {
     PrintPID("%8.0f ms: ", isolate()->time_millis_since_init());
     PrintF("Adjust amount of external memory: delta=%6" V8_PTR_PREFIX "d KB, "
            "amount=%6" V8_PTR_PREFIX "d KB, since_gc=%6" V8_PTR_PREFIX "d KB, "
            "isolate=0x%08" V8PRIxPTR ".\n",
            static_cast<intptr_t>(change_in_bytes / KB),
            static_cast<intptr_t>(amount_of_external_allocated_memory_ / KB),
            static_cast<intptr_t>(PromotedExternalMemorySize() / KB),
            reinterpret_cast<intptr_t>(isolate()));
@@ skipping 201 matching lines @@
 
 
 double GCTracer::SizeOfHeapObjects() {
   return (static_cast<double>(heap_->SizeOfObjects())) / MB;
 }
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_HEAP_INL_H_