Adjust external allocated memory using object-specific size value

Author: pinepain

src/php_v8_callbacks.cc

@@ -155,6 +155,24 @@ namespace phpv8 {
 
         return bucket.get();
     }
+
+    int64_t PersistentData::calculateSize() {
+        int64_t size = sizeof(*this);
+
+        for (auto const &item : buckets) {
+            size += sizeof(std::shared_ptr<CallbacksBucket>);
+            size += item.first.capacity();
+            size += item.second->calculateSize();
+        }
+
+        return size;
+    }
+
+    int64_t PersistentData::adjustSize(int64_t change_in_bytes) {
+        adjusted_size_ += change_in_bytes;
+        assert(adjusted_size_ >= 0);
+        return adjusted_size_;
+    }
 }
 
 void php_v8_callbacks_gc(phpv8::PersistentData *data, zval **gc_data, int * gc_data_count, zval **table, int *n) {

src/php_v8_callbacks.h

@@ -22,9 +22,11 @@ namespace phpv8 {
     template <class T> class PersistentCollection;
 }
 
+
 #include <v8.h>
 #include <map>
 #include <string>
+#include <utility>
 
 extern "C" {
 #include "php.h"
@@ -57,6 +59,13 @@ extern void php_v8_callback_indexed_property_enumerator(const v8::PropertyCallba
 
 extern bool php_v8_callback_access_check(v8::Local<v8::Context> accessing_context, v8::Local<v8::Object> accessed_object, v8::Local<v8::Value> data);
 
+//#define PHP_V8_DEBUG_EXTERNAL_MEM 1
+
+#ifdef PHP_V8_DEBUG_EXTERNAL_MEM
+#define php_v8_debug_external_mem(format, ...) fprintf(stderr, (format), ##__VA_ARGS__);
+#else
+#define php_v8_debug_external_mem(format, ...)
+#endif
 
 namespace phpv8 {
 
@@ -95,8 +104,13 @@ namespace phpv8 {
         inline bool empty() {
             return callbacks.empty();
         }
+
+        inline int64_t calculateSize() {
+            return sizeof(*this) + (sizeof(std::shared_ptr<Callback>) + sizeof(Callback)) * callbacks.size();
+        }
+
     private:
-        std::map<size_t, std::shared_ptr<phpv8::Callback>> callbacks;
+        std::map<size_t, std::shared_ptr<Callback>> callbacks;
     };
 
 
@@ -114,7 +128,20 @@ namespace phpv8 {
             return buckets.empty();
         }
 
+        int64_t calculateSize();
+
+        inline int64_t getTotalSize() {
+            if (!size_) {
+                size_ = calculateSize();
+            }
+
+            return size_ + adjusted_size_;
+        }
+
+        int64_t adjustSize(int64_t change_in_bytes);
     private:
+        int64_t size_;
+        int64_t adjusted_size_;
         std::map<std::string, std::shared_ptr<CallbacksBucket>> buckets;
     };
 
@@ -149,9 +176,20 @@ namespace phpv8 {
             collection[persistent] = std::shared_ptr<phpv8::PersistentData>(data);
         }
 
+        phpv8::PersistentData *get(v8::Persistent<T> *persistent) {
+            auto it = collection.find(persistent);
+
+            if (it != collection.end()) {
+                return it->second.get();
+            }
+
+            return nullptr;
+        }
+
         void remove(v8::Persistent<T, v8::NonCopyablePersistentTraits<T>> *persistent) {
             collection.erase(persistent);
-        }    private:
+        }
+    private:
         std::map<v8::Persistent<T> *, std::shared_ptr<phpv8::PersistentData>> collection;
     };
 }

src/php_v8_function_template.cc

@@ -42,13 +42,17 @@ static void php_v8_function_template_weak_callback(const v8::WeakCallbackInfo<v8
     v8::Isolate *isolate = data.GetIsolate();
     php_v8_isolate_t *php_v8_isolate = PHP_V8_ISOLATE_FETCH_REFERENCE(isolate);
 
-    php_v8_isolate->weak_function_templates->remove(data.GetParameter());
+    phpv8::PersistentData *persistent_data = php_v8_isolate->weak_function_templates->get(data.GetParameter());
+
+    if (persistent_data != nullptr) {
+        // Tell v8 that we release external allocated memory
+        php_v8_debug_external_mem("Free allocated external memory (func tpl: %p): -%" PRId64 "\n", persistent_data, persistent_data->getTotalSize())
+        isolate->AdjustAmountOfExternalAllocatedMemory(-persistent_data->getTotalSize());
+        php_v8_isolate->weak_function_templates->remove(data.GetParameter());
+    }
 
     data.GetParameter()->Reset();
     delete data.GetParameter();
-
-    // Tell v8 that we release external allocated memory
-    isolate->AdjustAmountOfExternalAllocatedMemory(-1024 * 1024 * 1024);
 }
 
 void php_v8_function_template_make_weak(php_v8_function_template_t *php_v8_function_template) {
@@ -57,7 +61,9 @@ void php_v8_function_template_make_weak(php_v8_function_template_t *php_v8_funct
     php_v8_function_template->is_weak = true;
     php_v8_function_template->persistent->SetWeak(php_v8_function_template->persistent, php_v8_function_template_weak_callback, v8::WeakCallbackType::kParameter);
 
-    php_v8_function_template->php_v8_isolate->isolate->AdjustAmountOfExternalAllocatedMemory(1024 * 1024 * 1024);
+    // Tell v8 that we allocated external memory
+    php_v8_debug_external_mem("Allocate external memory (func tpl: %p):  %" PRId64 "\n", php_v8_function_template->persistent_data, php_v8_function_template->persistent_data->getTotalSize())
+    php_v8_function_template->php_v8_isolate->isolate->AdjustAmountOfExternalAllocatedMemory(php_v8_function_template->persistent_data->getTotalSize());
 }
 
 

src/php_v8_isolate_limits.cc

@@ -22,8 +22,9 @@
 #define PHP_V8_TIME_SLEEP_MILLISECONDS 10
 
 //#define PHP_V8_DEBUG_EXECUTION 1
-
-#define mb(sz) ((sz)/1024/1024.0)
+#define one_mb (1024.0 * 1024.0)
+#define kb(sz) ((sz)/1024.0)
+#define mb(sz) (kb(sz)/1024.0)
 #define has(v, str) (v ? "has " str : "no " str)
 #define is(v) (v ? "yes" : "no")
 

src/php_v8_object_template.cc

@@ -45,13 +45,17 @@ static void php_v8_object_template_weak_callback(const v8::WeakCallbackInfo<v8::
     v8::Isolate *isolate = data.GetIsolate();
     php_v8_isolate_t *php_v8_isolate = PHP_V8_ISOLATE_FETCH_REFERENCE(isolate);
 
-    php_v8_isolate->weak_object_templates->remove(data.GetParameter());
+    phpv8::PersistentData *persistent_data = php_v8_isolate->weak_object_templates->get(data.GetParameter());
+
+    if (persistent_data != nullptr) {
+        // Tell v8 that we release external allocated memory
+        php_v8_debug_external_mem("Free allocated external memory (obj tpl: %p): -%" PRId64 "\n", persistent_data, persistent_data->getTotalSize())
+        isolate->AdjustAmountOfExternalAllocatedMemory(-persistent_data->getTotalSize());
+        php_v8_isolate->weak_object_templates->remove(data.GetParameter());
+    }
 
     data.GetParameter()->Reset();
     delete data.GetParameter();
-
-    // Tell v8 that we release external allocated memory
-    isolate->AdjustAmountOfExternalAllocatedMemory(-1024 * 1024 * 1024);
 }
 
 
@@ -61,7 +65,9 @@ static void php_v8_object_template_make_weak(php_v8_object_template_t *php_v8_ob
     php_v8_object_template->is_weak = true;
     php_v8_object_template->persistent->SetWeak(php_v8_object_template->persistent, php_v8_object_template_weak_callback, v8::WeakCallbackType::kParameter);
 
-    php_v8_object_template->php_v8_isolate->isolate->AdjustAmountOfExternalAllocatedMemory(1024 * 1024 * 1024);
+    // Tell v8 that we allocated external memory
+    php_v8_debug_external_mem("Allocate external memory (obj tpl: %p):  %" PRId64 "\n", php_v8_object_template->persistent_data, php_v8_object_template->persistent_data->getTotalSize())
+    php_v8_object_template->php_v8_isolate->isolate->AdjustAmountOfExternalAllocatedMemory(php_v8_object_template->persistent_data->getTotalSize());
 }
 
 static HashTable * php_v8_object_template_gc(zval *object, zval **table, int *n) {

src/php_v8_value.cc

@@ -62,7 +62,14 @@ static void php_v8_value_weak_callback(const v8::WeakCallbackInfo<v8::Persistent
     v8::Isolate *isolate = data.GetIsolate();
     php_v8_isolate_t *php_v8_isolate = PHP_V8_ISOLATE_FETCH_REFERENCE(isolate);
 
-    php_v8_isolate->weak_values->remove(data.GetParameter());
+    phpv8::PersistentData *persistent_data = php_v8_isolate->weak_values->get(data.GetParameter());
+
+    if (persistent_data != nullptr) {
+        // Tell v8 that we release external allocated memory
+        php_v8_debug_external_mem("Free allocated external memory (value: %p): -%" PRId64 "\n", persistent_data, persistent_data->getTotalSize())
+        isolate->AdjustAmountOfExternalAllocatedMemory(-persistent_data->getTotalSize());
+        php_v8_isolate->weak_values->remove(data.GetParameter());
+    }
 
     data.GetParameter()->Reset();
     delete data.GetParameter();
@@ -80,7 +87,9 @@ static void php_v8_value_make_weak(php_v8_value_t *php_v8_value) {
     php_v8_value->is_weak = true;
     php_v8_value->persistent->SetWeak(php_v8_value->persistent, php_v8_value_weak_callback, v8::WeakCallbackType::kParameter);
 
-    php_v8_value->php_v8_isolate->isolate->AdjustAmountOfExternalAllocatedMemory(1024 * 1024 * 1024);
+    // Tell v8 that we allocated external memory
+    php_v8_debug_external_mem("Allocate external memory (value: %p):  %" PRId64 "\n", php_v8_value->persistent_data, php_v8_value->persistent_data->getTotalSize())
+    php_v8_value->php_v8_isolate->isolate->AdjustAmountOfExternalAllocatedMemory(php_v8_value->persistent_data->getTotalSize());
 }
 
 static HashTable * php_v8_value_gc(zval *object, zval **table, int *n) {

tests/V8Exception_CreateMessage.phpt

@@ -71,6 +71,7 @@ $helper->line();
 
 $v8_helper->run_checks($res);
 ?>
+EOF
 --EXPECTF--
 Can create message when out of context: ok
 
@@ -180,3 +181,6 @@ V8\ObjectValue(V8\Value)->IsStringObject(): bool(false)
 V8\ObjectValue(V8\Value)->IsSymbolObject(): bool(false)
 V8\ObjectValue(V8\Value)->IsNativeError(): bool(false)
 V8\ObjectValue(V8\Value)->IsRegExp(): bool(false)
+
+
+EOF