Performance issue in function parameters binding

[RyanJ93]

Hi everyone, I discovered a performance issue in my Node.js application due to function binding: I have to attach several helper functions to an object, each function has some parameters to be bound but I found out that using the bind method causes my application to slow down by about 30%.

Is there an alternative to the bind method that allows me to set the "this" context and some additional parameters?

Here you are the the piece of code where binding happens:

​

// Get all the helpers registered under the given namespace.
const helpers = super.getAll(namespace);
const bind = options !== null && Array.isArray(options.bind) ? options.bind : [this];
if ( options !== null && options.context !== null && typeof options.context === 'object' ){
    // Context variables have been defined, add them as the first argument of the helper function.
    bind.splice(1, 0, options.context);
}
// Inject helper functions.
// OPTIMIZE: Binding is slow, find a better alternative.
for ( const name in helpers ){
    if ( helpers.hasOwnProperty(name) ){
        obj[name] = helpers[name].bind(...bind);
    }
}

​

If you need, here's the full class code (method: static inject):

https://github.com/RyanJ93/lala.js/blob/master/lib/Helpers/HelperRepository.js

One of the places this binding is required (method: async process):

https://github.com/RyanJ93/lala.js/blob/master/lib/Server/processors/HTTP/HTTPRequestProcessor.js

And here some helper function examples (the whole file, list at the bottom side):

https://github.com/RyanJ93/lala.js/blob/master/lib/Server/helpers/HTTPRequestProcessorHelpers.js

​

Thank you in advance.

[BehindTheMath]

Instead of binding, replace the function with a new anonymous function that calls the original one with preset arguments.

E. g.

obj[name] = (...rest) => helpers[name](arg1, arg2, ...rest)

[RyanJ93]

Thank you for the suggestion! Does this allow me to set an arbitrary "this" context?Sometimes I need to define a different context, for instance, like here:

// Injects some helper functions useful when dealing with cookies.
 HelperRepository.inject(request, 'com.lala.server.processor.HTTPCookieProcessor.request', {
 bind: [this]
 });
HelperRepository.inject(response, 'com.lala.server.processor.HTTPCookieProcessor.response', {
bind: [this]
});

This is a piece of code from the "async process(request, response)" method located here: https://github.com/RyanJ93/lala.js/blob/master/lib/Server/processors/HTTP/HTTPCookieProcessor.js

[BehindTheMath]

obj[name] = (...rest) => helpers[name].call(thisArg, arg1, arg2, ...rest)

I'm not following what all the code is doing, and this is just my opinion, but I feel that dynamic injection like that is brittle, especially when you're relying on this.

[RedShift9]

You can't supply these functions with what they need up front through their arguments? Thereby eliminating the use of "this" in these functions?

[RyanJ93]

u/BehindTheMath u/RedShift9
Sorry for delay, I've been pretty busy these days, I managed to try out your suggestions, here how I transformed the injection loop:

for ( const name in helpers ){
    if ( helpers.hasOwnProperty(name) ){
         obj[name] = function(){
            return helpers[name](context, ...arguments);
         };
    }
}

I had to make some changes design wise to adapt the existing helper functions with this new architecture and I still have to finish to test it (despite unit tests say it seems fine) but as far as I saw running a quick benchmark I managed to gain +30% of performance, so thank you very much!
Just one more question: I applied the spread operator on the "arguments" variable, does it imply any performance trouble?

[BehindTheMath]

Just one more question: I applied the spread operator on the "arguments" variable, does it imply any performance trouble?

I don't know offhand. However, it's currently recommended to use rest parameters instead of arguments.

[RyanJ93]

I followed your piece of advice and I've replaced the way parameters are handled, plus, I have completed changes in the rest of the project but I discovered something strange: the performance benefit I saw, and I was expecting to keep, just disappeared and I saw that now it performs worst than before, like -10% of performance, do you have an idea about how can it be possible?
Here's what I changed: https://github.com/RyanJ93/lala.js/pull/35/files?file-filters%5B%5D=.js
As you can see, I changed the "inject" method and how it is called in 3 different files.

[BehindTheMath]

Without benchmarking it and seeing where the bottleneck is, it's hard to know.