@auto_js/v8 0.0.8 → 0.0.9

package/CMakeLists.txt

@@ -64,6 +64,7 @@ if(v8_js STREQUAL isolated_v8_js)
 			isolated/clock.cc
 			isolated/cluster.cc
 			isolated/executor.cc
+			isolated/memory_policy.cc
 			isolated/platform.cc
 			platform/delegate.cc
 			platform/foreground_runner.cc
@@ -76,6 +77,7 @@ if(v8_js STREQUAL isolated_v8_js)
 			isolated/clock.h.cc
 			isolated/cluster.h.cc
 			isolated/executor.h.cc
+			isolated/memory_policy.h.cc
 			isolated/platform.h.cc
 			platform/delegate.h.cc
 			platform/foreground_runner.h.cc

package/_module.cc

@@ -24,6 +24,7 @@ export import :evaluation.script;
 export import :isolated.agent;
 export import :isolated.clock;
 export import :isolated.cluster;
+export import :isolated.memory_policy;
 export import :isolated.platform;
 export import :platform.delegate;
 export import :platform.foreground_runner;

package/handle/value_of.cc

@@ -9,9 +9,9 @@ namespace js::iv8 {
 template <class Tag>
 struct value_specialization;
 
-// nb: This corresponds to `js::napi::bound_value_of<T>`. `v8::Local<T>` is more like
-// `js::napi::value_of<T>`.
-template <class Tag>
+// nb: This corresponds to `js::napi::value_of<T>`. `v8::Local<T>` is more like
+// `js::napi::local_of<T>`.
+export template <class Tag>
 class value_of : public value_specialization<Tag>::type {
 	public:
 		using value_specialization<Tag>::type::type;
@@ -50,9 +50,13 @@ struct value_specialization<date_tag> : std::type_identity<class value_for_date>
 template <>
 struct value_specialization<external_tag> : std::type_identity<class value_for_external> {};
 
+// TODO: value_for_record
 template <>
 struct value_specialization<object_tag> : std::type_identity<class value_for_object> {};
 
+template <>
+struct value_specialization<list_tag> : std::type_identity<class value_for_object> {};
+
 template <>
 struct value_specialization<array_buffer_tag> : std::type_identity<class value_for_array_buffer> {};
 

package/isolated/agent.cc

@@ -75,18 +75,22 @@ agent_host::agent_host(
 	behavior_params params
 ) :
 		storage_{std::move(storage)},
+		memory_policy_{std::move(params.memory_policy)},
 		clock_{params.clock},
 		destroy_callback_{destroy_callback},
 		reset_handle_callback_{reset_handle_type{util::fn<&agent_host::remote_expiration_callback>, *this}},
 		random_seed_{params.random_seed} {
 	executor_.initialize([ & ](v8::Isolate* isolate) noexcept -> auto {
 		isolate->SetData(0, this);
-		auto create_params = v8::Isolate::CreateParams{};
-		create_params.array_buffer_allocator_shared =
-			std::shared_ptr<v8::ArrayBuffer::Allocator>(v8::ArrayBuffer::Allocator::NewDefaultAllocator());
-		return create_params;
+		v8::Isolate::CreateParams params;
+		auto memory_params = memory_policy_->make_create_params();
+		params.constraints = memory_params.constraints;
+		params.array_buffer_allocator_shared = std::move(memory_params.allocator);
+		return params;
 	});
-	executor_.isolate()->SetCaptureStackTraceForUncaughtExceptions(true);
+	auto* isolate = executor_.isolate();
+	isolate->SetCaptureStackTraceForUncaughtExceptions(true);
+	memory_policy_->initialize(isolate);
 }
 
 agent_host::~agent_host() {

package/isolated/agent.h.cc

@@ -4,6 +4,7 @@ export module v8_js:isolated.agent;
 import :collected_handle;
 import :isolated.clock;
 import :isolated.executor;
+import :isolated.memory_policy;
 import :platform.foreground_runner;
 import :remote;
 import std;
@@ -18,6 +19,7 @@ class agent_host_of;
 
 // `agent_host` behavior parameters
 export struct behavior_params {
+		memory_policy::covariant memory_policy;
 		clock::any_clock clock;
 		std::optional<double> random_seed;
 };
@@ -146,6 +148,7 @@ export class agent_host
 		// Order matters for these members
 		std::shared_ptr<agent_storage> storage_;
 		isolated::executor executor_;
+		isolated::memory_policy::covariant memory_policy_;
 
 		// Order doesn't really matter
 		bool should_give_seed_{};

package/isolated/memory_policy.cc

@@ -0,0 +1,49 @@
+module v8_js;
+import :isolated.memory_policy;
+
+namespace js::iv8::isolated {
+
+// memory_policy::none
+auto memory_policy::none::make_create_params() -> create_params {
+	return {
+		.allocator = std::shared_ptr<v8::ArrayBuffer::Allocator>(v8::ArrayBuffer::Allocator::NewDefaultAllocator()),
+		.constraints = {}
+	};
+}
+
+// memory_policy::limited
+auto memory_policy::limited::initialize(v8::Isolate* isolate) -> void {
+	isolate->AddNearHeapLimitCallback(
+		// NOLINTNEXTLINE(bugprone-easily-swappable-parameters)
+		[](void* data, std::size_t current_heap_limit, std::size_t initial_heap_limit) -> std::size_t {
+			auto& self = *static_cast<memory_policy::limited*>(data);
+			return self.near_heap_limit_callback(current_heap_limit, initial_heap_limit);
+		},
+		this
+	);
+}
+
+auto memory_policy::limited::make_create_params() -> create_params {
+	v8::ResourceConstraints constraints{};
+	constraints.ConfigureDefaultsFromHeapSize(0, memory_limit_);
+	return {
+		.allocator = std::shared_ptr<v8::ArrayBuffer::Allocator>(v8::ArrayBuffer::Allocator::NewDefaultAllocator()),
+		.constraints = constraints,
+	};
+}
+
+// NOLINTNEXTLINE(bugprone-easily-swappable-parameters)
+auto memory_policy::limited::near_heap_limit_callback(std::size_t current_heap_limit, std::size_t /*initial_heap_limit*/) const -> std::size_t {
+	auto* isolate = v8::Isolate::GetCurrent();
+	v8::HeapStatistics heap;
+	isolate->GetHeapStatistics(&heap);
+
+	if (current_heap_limit > memory_limit_) {
+		auto& executor = agent_host::get_current(isolate).executor();
+		executor.terminate();
+	}
+	// Increase heap limit 64mb at a time
+	return current_heap_limit + (64 << 20);
+}
+
+} // namespace js::iv8::isolated

package/isolated/memory_policy.h.cc

@@ -0,0 +1,48 @@
+export module v8_js:isolated.memory_policy;
+import std;
+import util;
+import v8;
+
+namespace js::iv8::isolated {
+
+export class memory_policy {
+	protected:
+		~memory_policy() = default;
+
+	public:
+		struct create_params;
+
+		// NOLINTNEXTLINE(cppcoreguidelines-virtual-class-destructor)
+		class none;
+		// NOLINTNEXTLINE(cppcoreguidelines-virtual-class-destructor)
+		class limited;
+
+		virtual auto initialize(v8::Isolate* isolate) -> void = 0;
+		virtual auto make_create_params() -> create_params = 0;
+		// virtual auto check_soft_limit(v8::Isolate* isolate) -> bool = 0;
+		using covariant = util::covariant_value<memory_policy, none, limited>;
+};
+
+struct memory_policy::create_params {
+		std::shared_ptr<v8::ArrayBuffer::Allocator> allocator;
+		v8::ResourceConstraints constraints;
+};
+
+class memory_policy::none final : public memory_policy {
+	public:
+		auto initialize(v8::Isolate* isolate) -> void override {};
+		auto make_create_params() -> create_params override;
+};
+
+class memory_policy::limited final : public memory_policy {
+	public:
+		explicit limited(std::size_t memory_limit_bytes) : memory_limit_{memory_limit_bytes} {}
+		auto initialize(v8::Isolate* isolate) -> void override;
+		auto make_create_params() -> create_params override;
+
+	private:
+		std::size_t memory_limit_;
+		[[nodiscard]] auto near_heap_limit_callback(std::size_t current_heap_limit, std::size_t initial_heap_limit) const -> std::size_t;
+};
+
+} // namespace js::iv8::isolated

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@auto_js/v8",
-  "version": "0.0.8",
+  "version": "0.0.9",
   "author": "https://github.com/laverdet/",
   "homepage": "https://github.com/laverdet/isolated-vm/tree/experimental/packages/auto_js/v8",
   "license": "ISC",
   "dependencies": {
-    "@auto_js/v8_exports": "^0.0.6",
-    "@auto_js/js": "^0.0.8"
+    "@auto_js/js": "^0.0.9",
+    "@auto_js/v8_exports": "^0.0.7"
   },
   "repository": {
     "type": "git",

package/transfer/accept.h.cc

@@ -1,5 +1,6 @@
 export module v8_js:accept;
 import :callback_storage;
+import :handle.value;
 import :hash;
 import :value;
 import auto_js;
@@ -370,6 +371,20 @@ struct accept_v8_property_value {
 		accept_value<Meta, Type> second;
 };
 
+// Forward `value_of<T>`
+template <class Tag>
+struct accept_v8_value_of {
+	public:
+		explicit accept_v8_value_of(auto* /*transfer*/) {}
+
+		auto operator()(Tag /*tag*/, visit_holder /*visit*/, value_of<Tag> subject) const -> value_of<Tag> {
+			return subject;
+		}
+
+		consteval static auto accept_tags_of() { return std::tuple{Tag{}}; }
+		consteval static auto types(auto /*recursive*/) { return util::type_pack{}; }
+};
+
 // `return_into(...)`
 struct return_into_marker {};
 
@@ -475,6 +490,12 @@ struct accept<Meta, v8::Local<Type>> : iv8::accept_v8_value_with<typename Meta::
 		using iv8::accept_v8_value_with<typename Meta::accept_context_type>::accept_v8_value_with;
 };
 
+// forward `value_of<T>`
+template <class Meta, class Tag>
+struct accept<Meta, iv8::value_of<Tag>> : iv8::accept_v8_value_of<Tag> {
+		using iv8::accept_v8_value_of<Tag>::accept_v8_value_of;
+};
+
 // templates
 template <class Meta, class Type>
 	requires std::is_convertible_v<Type, v8::Template>

package/transfer/visit.cc

@@ -380,7 +380,7 @@ struct visit_value : visit_flat_value<Target> {
 		template <class Accept>
 		auto immediate(v8::Local<v8::Array> subject, const Accept& accept) -> accept_target_t<Accept> {
 			auto visit_entry = visit_entry_pair<visit_property_name<visit_value>, visit_value&>{*this};
-			return accept(list_tag{}, visit_entry, value_of{witness(), subject.As<v8::Object>()});
+			return accept(list_tag{}, visit_entry, value_of{witness(), subject.As<v8::Array>()});
 		}
 
 		// function template
@@ -433,6 +433,40 @@ struct visit_value : visit_flat_value<Target> {
 		v8::Local<v8::Context> context_;
 };
 
+// Forward `value_of<T>` back to acceptor
+template <class Tag>
+struct visit_v8_value_of {
+	private:
+		using visit_type = visit_value<void>;
+
+	public:
+		constexpr explicit visit_v8_value_of(auto* transfer, context_lock_witness lock) : visit_{transfer, lock} {}
+
+		template <class Accept>
+		constexpr auto operator()(value_of<Tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+			return accept(Tag{}, visit_, subject);
+		}
+
+		template <class Accept>
+			requires std::is_same_v<Tag, object_tag>
+		constexpr auto operator()(value_of<object_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+			auto visit_entry = visit_entry_pair<visit_property_name<visit_type>, visit_type&>{visit_};
+			return accept(object_tag{}, visit_entry, subject);
+		}
+
+		template <class Accept>
+			requires std::is_same_v<Tag, list_tag>
+		constexpr auto operator()(value_of<list_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+			auto visit_entry = visit_entry_pair<visit_property_name<visit_type>, visit_type&>{visit_};
+			return accept(list_tag{}, visit_entry, subject);
+		}
+
+		consteval static auto types(auto /*recursive*/) { return util::type_pack{}; }
+
+	private:
+		visit_type visit_;
+};
+
 // Template visitor needs no lock. The acceptor will instantiate values.
 struct visit_template {
 		explicit visit_template(auto* /*transfer*/) {}
@@ -467,6 +501,15 @@ struct visit<Meta, v8::Local<Type>> : iv8::visit_value_with<Meta> {
 		using iv8::visit_value_with<Meta>::visit_value_with;
 };
 
+// value_of<T> visitor
+template <class Meta, class Tag>
+struct visit<Meta, iv8::value_of<Tag>> : iv8::visit_v8_value_of<Tag> {
+		using iv8::visit_v8_value_of<Tag>::visit_v8_value_of;
+};
+
+template <class Tag>
+struct visit_subject_for<iv8::value_of<Tag>> : std::type_identity<v8::Local<v8::Value>> {};
+
 // Template visitor
 template <class Meta, class Type>
 	requires std::is_convertible_v<Type, v8::Template>