Draft: Add custom allocator support

Signed-off-by: Jonathan Schwender <[email protected]>

Author: jschwe

Cargo.toml

@@ -1,5 +1,5 @@
 [workspace]
-members = ["mozjs-sys", "mozjs"]
+members = ["mozjs-sys", "mozjs", "examples/embedder_allocator"]
 resolver = "2"
 
 [workspace.package]

examples/embedder_allocator/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "embedder_allocator"
+version = "0.1.0"
+repository.workspace = true
+license.workspace = true
+edition.workspace = true
+description = "Example usage of mozjs, with the embedder (this crate) providing a custom allocator for mozjs"
+publish = false
+
+[dependencies]
+mozjs = { path =  "../../mozjs", features = ["custom-alloc"] }
+mimalloc = "0.1.48"

examples/embedder_allocator/Readme.md

@@ -0,0 +1,2 @@
+# Example: Using mozjs with an embedder-provided allocator
+

examples/embedder_allocator/build.py

@@ -0,0 +1,29 @@
+#!/usr/bin/env python3
+
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+# This file
+
+import os
+import pathlib
+import subprocess
+import sys
+from typing import Mapping
+
+def create_env() -> Mapping[str, str]:
+    env = os.environ.copy()
+    mimalloc_include_dir = pathlib.Path(__file__).parent.joinpath('mimalloc/include')
+    assert mimalloc_include_dir.is_dir(), "Could not find mimalloc include directory"
+    env['SERVO_CUSTOM_ALLOC_INCLUDE_DIR'] = mimalloc_include_dir.as_posix()
+    return env
+
+
+def main():
+    completed_process = subprocess.run(sys.argv[1:], env=create_env())
+    sys.exit(completed_process.returncode)
+
+
+if __name__ == '__main__':
+    main()

examples/embedder_allocator/build.rs

@@ -0,0 +1,4 @@
+fn main() {
+    // todo: Should we do this here or in the mozjs-sys build-script?
+    println!("cargo:rustc-link-lib=mimalloc");
+}

mozjs-sys/src/custom_alloc/mimalloc.h renamed to examples/embedder_allocator/mimalloc/include/mimalloc.h

@@ -0,0 +1,5 @@
+#pragma once
+
+/// Defines the prefix for all malloc functions, i.e.
+/// mi_malloc, mi_calloc, mi_realloc, mi_free etc.
+#define SERVO_EMBEDDER_MALLOC_PREFIX mi_

examples/embedder_allocator/mimalloc/include/servo_embedder_malloc_prefix.h

@@ -0,0 +1,10 @@
+#pragma once
+
+#include <mimalloc.h>
+#include "servo_embedder_malloc_prefix.h"
+
+#define SERVO_CONCAT(x, y) x ## y
+#define SERVO_CONCAT2(x, y) SERVO_CONCAT(x, y)
+
+#define mozmem_malloc_impl(fn) SERVO_CONCAT2(SERVO_EMBEDDER_MALLOC_PREFIX, fn)
+#define mozmem_dup_impl(fn) SERVO_CONCAT2(SERVO_EMBEDDER_MALLOC_PREFIX, fn)

examples/embedder_allocator/mimalloc/include/servo_embedder_memory_wrap.h

@@ -0,0 +1,76 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+use std::ptr;
+use std::sync::mpsc::channel;
+use std::thread;
+
+use mozjs::jsapi::GCContext;
+use mozjs::jsapi::JSCLASS_FOREGROUND_FINALIZE;
+use mozjs::jsapi::{JSClass, JSClassOps, JSObject, OnNewGlobalHookOption};
+use mozjs::realm::AutoRealm;
+use mozjs::rooted;
+use mozjs::rust::wrappers2::{JS_NewGlobalObject, JS_NewObject};
+use mozjs::rust::{JSEngine, RealmOptions, Runtime, SIMPLE_GLOBAL_CLASS};
+
+fn main() {
+    println!("Hello, world!");
+    let engine = JSEngine::init().expect("Could not init JSEngine");
+    println!("JSEngine initialized");
+    let mut runtime = Runtime::new(engine.handle());
+    println!("Runtime initialized");
+    let context = runtime.cx();
+    let h_option = OnNewGlobalHookOption::FireOnNewGlobalHook;
+    let c_option = RealmOptions::default();
+
+    unsafe {
+        rooted!(&in(context) let global = JS_NewGlobalObject(
+            context,
+            &SIMPLE_GLOBAL_CLASS,
+            ptr::null_mut(),
+            h_option,
+            &*c_option,
+        ));
+        let mut realm = AutoRealm::new_from_handle(context, global.handle());
+        let context = &mut realm;
+        rooted!(&in(context) let _object = JS_NewObject(context, &CLASS as *const _));
+    }
+
+    let parent = runtime.prepare_for_new_child();
+    let (sender, receiver) = channel();
+    thread::spawn(move || {
+        let runtime = unsafe { Runtime::create_with_parent(parent) };
+        assert!(Runtime::get().is_some());
+        drop(runtime);
+        let _ = sender.send(());
+    });
+    let _ = receiver.recv();
+    println!("Example ran without issues...");
+}
+
+unsafe extern "C" fn finalize(_fop: *mut GCContext, _object: *mut JSObject) {
+    assert!(Runtime::get().is_some());
+}
+
+static CLASS_OPS: JSClassOps = JSClassOps {
+    addProperty: None,
+    delProperty: None,
+    enumerate: None,
+    newEnumerate: None,
+    resolve: None,
+    mayResolve: None,
+    finalize: Some(finalize),
+    call: None,
+    construct: None,
+    trace: None,
+};
+
+static CLASS: JSClass = JSClass {
+    name: c"EventTargetPrototype".as_ptr(),
+    flags: JSCLASS_FOREGROUND_FINALIZE,
+    cOps: &CLASS_OPS as *const JSClassOps,
+    spec: ptr::null(),
+    ext: ptr::null(),
+    oOps: ptr::null(),
+};

examples/embedder_allocator/src/main.rs

@@ -16,8 +16,8 @@ name = "mozjs_sys"
 doctest = false
 
 [features]
-default = ["custom-malloc"] # Testing only - remove me
-custom-malloc = []
+default = []
+custom-alloc = []
 debugmozjs = []
 profilemozjs = []
 jit = []
@@ -29,8 +29,6 @@ crown = []
 oom_with_hook = []
 
 [dependencies]
-# remove-me
-mimalloc = { version = "0.1.48", optional = true}
 libc.workspace = true
 encoding_c = "0.9.8"
 encoding_c_mem = "0.2.6"