Allocating JS Array Size

[harumazzz]

When initialize an Array in C, you do this:

int* a = (int*)malloc(sizeof(int) * 1000);
// An array of 1000 elements
// some work
free(a);

or this

int a[1000]; // same b

In quickjs-ng, we have to define an Array, iterate through the list, set the property uint32, and quickjs manage the index manually so that the Array is never out of bounds and there is no undefined behavior. I want to ask is there anyway to allocate the new array with 1000 elements directly (so that quickjs don't have to reallocate too much). Thanks!

[saghul]

You could allocate an array and then set its length to 1000. That's 2 steps still, but an improvement.

[bnoordhuis]

A new JSValue JS_NewArrayFrom(JSContext *ctx, int count, JSValue *values) isn't out of the question, IMO. Most JS engines have a similar API.

[harumazzz]

Out of curiosity, but can you add the support for object too (for allocating how many key, value pair needed). Because actually the object case is similar to this, but instead of atom uint32 is an atom of cstring, still need to iterate through and then set property.

[bnoordhuis]

Not in a way that's both ergonomic and efficient, I think.

JSValue JS_NewObjectFrom(JSContext *ctx, int count, char **props, JSValue *values) is ergonomic for you as a quickjs user. QuickJS on the other hand has to convert the property strings to atoms one by one.¹ It's roughly equal to JS_NewObject() + JS_SetPropertyStr() in terms of performance.

JSValue JS_NewObjectFrom(JSContext *ctx, int count, JSAtom *props, JSValue *values) forces you to do the conversion upfront. It'd be efficient because we can compute the final object shape upfront, but for you as a quickjs user is less ergonomic.

¹ We could convert properties in batches of 16 or 32, to reduce the number of object shape transitions. I'll investigate if that's a worthwhile optimization.

[bnoordhuis]

Forgot to mention: JS_NewObject() + JS_SetPropertyFunctionList() already cover many use cases.

JSCFunctionListEntry props[] = {
    JS_PROP_STRING_DEF("foo", "bar", JS_PROP_C_W_E),
    JS_PROP_INT32_DEF("answer", 42, JS_PROP_C_W_E),
    // etc. - see the JS_PROP_ macros in quickjs.h
};
JSValue obj = JS_NewObject(ctx);
JS_SetPropertyFunctionList(ctx, obj, props, sizeof(props)/sizeof(*props));

[bnoordhuis]

I've opened #871 for discussion/review. I'm still somewhat undecided if they're actually good additions to the API but it cannot be denied that they're quite a bit faster when you're creating many objects or objects with many properties.

[harumazzz]

For me, I honestly believe that this API is good for code optimization and faster for creating such large object with many property. It provides a simpler interface than manually JS_NewObject + JS_SetPropertyStr, and faster for creating large object.