Allow to execute some code before cloning.

Author: xeioex

src/njs.h

@@ -139,6 +139,7 @@ typedef enum {
     NJS_ENUM_STRING = 8,
     NJS_ENUM_SYMBOL = 16,
     NJS_ENUM_ENUMERABLE_ONLY = 32,
+    NJS_ENUM_NON_SHARED_ONLY = 64,
 } njs_object_enum_t;
 
 
@@ -302,6 +303,7 @@ NJS_EXPORT njs_mod_t *njs_vm_add_module(njs_vm_t *vm, njs_str_t *name,
     njs_value_t *value);
 NJS_EXPORT njs_mod_t *njs_vm_compile_module(njs_vm_t *vm, njs_str_t *name,
     u_char **start, u_char *end);
+NJS_EXPORT njs_int_t njs_vm_reuse(njs_vm_t *vm);
 NJS_EXPORT njs_vm_t *njs_vm_clone(njs_vm_t *vm, njs_external_ptr_t external);
 
 NJS_EXPORT njs_int_t njs_vm_enqueue_job(njs_vm_t *vm, njs_function_t *function,

src/njs_builtin.c

@@ -873,6 +873,8 @@ njs_top_level_object(njs_vm_t *vm, njs_object_prop_t *self,
         if (njs_slow_path(object == NULL)) {
             return NJS_ERROR;
         }
+
+        object->__proto__ = njs_vm_proto(vm, NJS_OBJ_TYPE_OBJECT);
     }
 
     prop = njs_object_prop_alloc(vm, &self->name, retval, 1);
@@ -920,6 +922,8 @@ njs_top_level_constructor(njs_vm_t *vm, njs_object_prop_t *self,
         ctor = &njs_vm_ctor(vm, njs_prop_magic16(self));
 
         njs_set_function(retval, ctor);
+
+        return NJS_OK;
     }
 
     prop = njs_object_prop_alloc(vm, &self->name, retval, 1);

src/njs_object.c

@@ -65,21 +65,45 @@ njs_object_t *
 njs_object_value_copy(njs_vm_t *vm, njs_value_t *value)
 {
     size_t        size;
-    njs_object_t  *object;
+    njs_object_t  *object, *proto;
 
     object = njs_object(value);
 
     if (!object->shared) {
         return object;
     }
 
-    size = njs_is_object_value(value) ? sizeof(njs_object_value_t)
-                                      : sizeof(njs_object_t);
+    switch (object->type) {
+    case NJS_OBJECT:
+        size = sizeof(njs_object_t);
+        proto = (object->__proto__ != NULL)
+                    ? njs_vm_proto(vm, NJS_OBJ_TYPE_OBJECT)
+                    : NULL;
+        break;
+    case NJS_ARRAY:
+        size = sizeof(njs_array_t);
+        njs_assert_msg(!object->fast_array,
+                       "shared fast_array is not supported");
+        proto = (object->__proto__ != NULL)
+                    ? njs_vm_proto(vm, NJS_OBJ_TYPE_ARRAY)
+                    : NULL;
+        break;
+    case NJS_OBJECT_VALUE:
+        size = sizeof(njs_object_value_t);
+        proto = (object->__proto__ != NULL)
+                    ? njs_vm_proto(vm, NJS_OBJ_TYPE_OBJECT)
+                    : NULL;
+        break;
+    default:
+        njs_internal_error(vm, "unexpected object type to copy");
+        return NULL;
+    }
+
     object = njs_mp_alloc(vm->mem_pool, size);
 
     if (njs_fast_path(object != NULL)) {
         memcpy(object, njs_object(value), size);
-        object->__proto__ = njs_vm_proto(vm, NJS_OBJ_TYPE_OBJECT);
+        object->__proto__ = proto;
         object->shared = 0;
         value->data.u.object = object;
         return object;
@@ -917,6 +941,10 @@ njs_get_own_ordered_keys(njs_vm_t *vm, const njs_object_t *object,
     njs_lvlhsh_each_init(&lhe, &njs_object_hash_proto);
     hash = &object->shared_hash;
 
+    if (flags & NJS_ENUM_NON_SHARED_ONLY) {
+        goto local_hash;
+    }
+
     for ( ;; ) {
         prop = njs_lvlhsh_each(hash, &lhe);
 
@@ -984,6 +1012,8 @@ njs_get_own_ordered_keys(njs_vm_t *vm, const njs_object_t *object,
         }
     }
 
+local_hash:
+
     njs_lvlhsh_each_init(&lhe, &njs_object_hash_proto);
     hash = &object->hash;
 
@@ -1187,6 +1217,189 @@ njs_traverse_visited(njs_arr_t *list, const njs_value_t *value)
 }
 
 
+static njs_int_t
+njs_object_copy_shared_hash(njs_vm_t *vm, njs_object_t *object)
+{
+    njs_int_t            ret;
+    njs_flathsh_t        new_hash, *shared_hash;
+    njs_object_prop_t    *prop;
+    njs_flathsh_each_t   fhe;
+    njs_flathsh_query_t  fhq;
+
+    fhq.replace = 0;
+    fhq.proto = &njs_object_hash_proto;
+    fhq.pool = vm->mem_pool;
+
+    njs_flathsh_init(&new_hash);
+    shared_hash = &object->shared_hash;
+
+    njs_flathsh_each_init(&fhe, &njs_object_hash_proto);
+
+    for ( ;; ) {
+        prop = njs_flathsh_each(shared_hash, &fhe);
+
+        if (prop == NULL) {
+            break;
+        }
+
+        if (njs_is_symbol(&prop->name)) {
+            fhq.key_hash = njs_symbol_key(&prop->name);
+            fhq.key.start = NULL;
+
+        } else {
+            njs_string_get(&prop->name, &fhq.key);
+            fhq.key_hash = njs_djb_hash(fhq.key.start, fhq.key.length);
+        }
+
+        fhq.value = prop;
+
+        ret = njs_flathsh_insert(&new_hash, &fhq);
+        if (njs_slow_path(ret != NJS_OK)) {
+            njs_internal_error(vm, "flathsh insert failed");
+            return NJS_ERROR;
+        }
+    }
+
+    object->shared_hash = new_hash;
+
+    return NJS_OK;
+}
+
+
+njs_int_t
+njs_object_make_shared(njs_vm_t *vm, njs_object_t *object)
+{
+    njs_int_t             ret;
+    njs_arr_t             visited;
+    njs_object_t          **start;
+    njs_value_t           value, *key;
+    njs_traverse_t        *s;
+    njs_object_prop_t     *prop;
+    njs_property_query_t  pq;
+    njs_traverse_t        state[NJS_TRAVERSE_MAX_DEPTH];
+
+    s = &state[0];
+    s->parent = NULL;
+    s->index = 0;
+    njs_set_object(&s->value, object);
+
+    s->keys = njs_value_own_enumerate(vm, &s->value, NJS_ENUM_KEYS
+                                      | NJS_ENUM_STRING
+                                      | NJS_ENUM_NON_SHARED_ONLY);
+    if (njs_slow_path(s->keys == NULL)) {
+        return NJS_ERROR;
+    }
+
+    if (s->keys->length != 0
+        && !njs_flathsh_is_empty(&object->shared_hash))
+    {
+        /*
+         * object->shared_hash can be shared with other objects
+         * and we do not want to modify other objects.
+         */
+
+        ret = njs_object_copy_shared_hash(vm, object);
+        if (njs_slow_path(ret != NJS_OK)) {
+            return NJS_ERROR;
+        }
+    }
+
+    start = njs_arr_init(vm->mem_pool, &visited, NULL, 8, sizeof(void *));
+    if (njs_slow_path(start == NULL)) {
+        return NJS_ERROR;
+    }
+
+    (void) njs_traverse_visit(&visited, &s->value);
+
+    pq.lhq.replace = 0;
+    pq.lhq.pool = vm->mem_pool;
+
+    for ( ;; ) {
+
+        if (s->index >= s->keys->length) {
+            njs_flathsh_init(&njs_object(&s->value)->hash);
+            njs_object(&s->value)->shared = 1;
+            njs_array_destroy(vm, s->keys);
+            s->keys = NULL;
+
+            if (s == &state[0]) {
+                goto done;
+            }
+
+            s--;
+            continue;
+        }
+
+
+        njs_property_query_init(&pq, NJS_PROPERTY_QUERY_GET, 0, 0);
+        key = &s->keys->start[s->index++];
+
+        ret = njs_property_query(vm, &pq, &s->value, key);
+        if (njs_slow_path(ret != NJS_OK)) {
+            if (ret == NJS_DECLINED) {
+                continue;
+            }
+
+            return NJS_ERROR;
+        }
+
+
+        prop = pq.lhq.value;
+
+        ret = njs_flathsh_insert(&njs_object(&s->value)->shared_hash, &pq.lhq);
+        if (njs_slow_path(ret != NJS_OK)) {
+            njs_internal_error(vm, "flathsh insert failed");
+            return NJS_ERROR;
+        }
+
+        njs_value_assign(&value, njs_prop_value(prop));
+
+        if (njs_is_object(&value)
+            && !njs_object(&value)->shared
+            && !njs_traverse_visited(&visited, &value))
+        {
+            ret = njs_traverse_visit(&visited, &value);
+            if (njs_slow_path(ret != NJS_OK)) {
+                return NJS_ERROR;
+            }
+
+            if (s == &state[NJS_TRAVERSE_MAX_DEPTH - 1]) {
+                njs_type_error(vm, "njs_object_traverse() recursion limit:%d",
+                               NJS_TRAVERSE_MAX_DEPTH);
+                return NJS_ERROR;
+            }
+
+            s++;
+            s->prop = NULL;
+            s->parent = &s[-1];
+            s->index = 0;
+            njs_value_assign(&s->value, &value);
+            s->keys = njs_value_own_enumerate(vm, &s->value, NJS_ENUM_KEYS
+                                           | NJS_ENUM_STRING
+                                           | NJS_ENUM_NON_SHARED_ONLY);
+            if (njs_slow_path(s->keys == NULL)) {
+                return NJS_ERROR;
+            }
+
+            if (s->keys->length != 0
+                && !njs_flathsh_is_empty(&njs_object(&s->value)->shared_hash))
+            {
+                ret = njs_object_copy_shared_hash(vm, njs_object(&s->value));
+                if (njs_slow_path(ret != NJS_OK)) {
+                    return NJS_ERROR;
+                }
+            }
+        }
+    }
+
+done:
+
+    njs_arr_destroy(&visited);
+
+    return NJS_OK;
+}
+
+
 njs_int_t
 njs_object_traverse(njs_vm_t *vm, njs_object_t *object, void *ctx,
     njs_object_traverse_cb_t cb)

src/njs_object.h

@@ -72,6 +72,7 @@ njs_array_t *njs_object_own_enumerate(njs_vm_t *vm, const njs_object_t *object,
     uint32_t flags);
 njs_int_t njs_object_traverse(njs_vm_t *vm, njs_object_t *object, void *ctx,
     njs_object_traverse_cb_t cb);
+njs_int_t njs_object_make_shared(njs_vm_t *vm, njs_object_t *object);
 njs_int_t njs_object_hash_create(njs_vm_t *vm, njs_lvlhsh_t *hash,
     const njs_object_prop_t *prop, njs_uint_t n);
 njs_int_t njs_primitive_prototype_get_proto(njs_vm_t *vm,

src/njs_object_prop.c

@@ -694,6 +694,7 @@ njs_prop_private_copy(njs_vm_t *vm, njs_property_query_t *pq,
 
     switch (value->type) {
     case NJS_OBJECT:
+    case NJS_ARRAY:
     case NJS_OBJECT_VALUE:
         object = njs_object_value_copy(vm, value);
         if (njs_slow_path(object == NULL)) {

src/njs_vm.c

@@ -378,6 +378,17 @@ njs_vm_compile_module(njs_vm_t *vm, njs_str_t *name, u_char **start,
 }
 
 
+njs_int_t
+njs_vm_reuse(njs_vm_t *vm)
+{
+    vm->active_frame = NULL;
+    vm->top_frame = NULL;
+    vm->modules = NULL;
+
+    return njs_object_make_shared(vm, njs_object(&vm->global_value));
+}
+
+
 njs_vm_t *
 njs_vm_clone(njs_vm_t *vm, njs_external_ptr_t external)
 {
@@ -464,17 +475,19 @@ njs_vm_runtime_init(njs_vm_t *vm)
     njs_int_t    ret;
     njs_frame_t  *frame;
 
-    frame = (njs_frame_t *) njs_function_frame_alloc(vm, NJS_FRAME_SIZE);
-    if (njs_slow_path(frame == NULL)) {
-        njs_memory_error(vm);
-        return NJS_ERROR;
-    }
+    if (vm->active_frame == NULL) {
+        frame = (njs_frame_t *) njs_function_frame_alloc(vm, NJS_FRAME_SIZE);
+        if (njs_slow_path(frame == NULL)) {
+            njs_memory_error(vm);
+            return NJS_ERROR;
+        }
 
-    frame->exception.catch = NULL;
-    frame->exception.next = NULL;
-    frame->previous_active_frame = NULL;
+        frame->exception.catch = NULL;
+        frame->exception.next = NULL;
+        frame->previous_active_frame = NULL;
 
-    vm->active_frame = frame;
+        vm->active_frame = frame;
+    }
 
     ret = njs_regexp_init(vm);
     if (njs_slow_path(ret != NJS_OK)) {

src/njs_vmcode.c

@@ -2600,6 +2600,8 @@ njs_vmcode_import(njs_vm_t *vm, njs_mod_t *module, njs_value_t *retval)
         njs_memzero(m->start, m->items * sizeof(njs_value_t));
     }
 
+    njs_assert(module->index < vm->modules->items);
+
     value = njs_arr_item(vm->modules, module->index);
 
     if (!njs_is_null(value)) {