Limited function calls in nodejs with the same operation?

Question

I am currently working on some scientific calculations for which my basic calculation cycles are performed over and over again with recursive calls if at least one parameter is false.

My nodejs server is currently stopping at about the 905-915th recursive function call.

It is strange that it does not fall and does not display any errors. It just stops doing anything -> more magazines, etc.

Is this some kind of node protection behavior to avoid overflow?

I have been struggling with this for several weeks, trying to limit the “loops” with the most reasonable software possible.

Thank you for your help and advice. Cheers Noah.

As requested, I provide some abstraction of my actual code

Hope this helps. I can’t put my original code here, because it consists of lines of more than 1.5 thousand - a lot can be verified. But the example below covers the basic logic of a recursive call.

// Contains objects which contain an array // which represents the amount of the ex_obj terms var amount = { a:[10,10], b:[7.5,7.5], c:[2.5,2.5,2.5,2.5] } // Contains objects, which contain an array of other objects // that represent some selection // Each object in an array consists of different values per attribute per 1 amount var ex_obj = { a: [ {aa: 1.41, ab: 0.143, ac: 0.5}, {aa: 1.30, ab: 1.43, ac: 0.42} ], b: [ {aa: 0.32, ab: 5.54, ac: 1.3}, {aa: 0.33, ab: 4.49, ac: 2.5} ], c: [ {aa: 0.54, ab: 1.4, ac: 3.5}, {aa: 0.39, ab: 1.434, ac: 3.91}, {aa: 0.231, ab: 1.44324, ac: 2.91}, {aa: 0.659, ab: 1.554, ac: 3.9124}, ] } // Here we have an object that represents // the "to be" state which should be achieved var should_be ={ aa: 14.534, ab: 3.43, ac: 5.534 } function calculate(){ // Now we want to mulitply the amount object values with // the ex_obj values for(let prop in ex_obj){ for(let i = 0, i < ex_obj[prop].length, i++){ for(let propa in ex_obj[prop][i]){ // here every aa,ab,ac gets mulitplied with the // contains of the amount obj for the matching // propertyname } } } // the next step is to check if the sum of all ex_obj property // child values per aa, ab and ac match the should_be propertie values // if everything is above the should_be and not too high then the // programm can stop here and print out the amount obj. // if the sum of the ex_obj properties is too little // compared to the should_be obj // we need to check which property is too little // eg aa is too little // then we check where aa in the ex_obj per 1 value is // the highest // then we increment the matching amount property child // and start calculate() again // same procedure for - if something is too much } 

Answer 1

Since your code is not complete, it's hard to say exactly what is going wrong. If you exceed the limit on the node call stack, you will get an exception, although 1000 recursions are usually not a problem.

Perhaps you are delaying the Node.js. event loop Instead of directly calling a recursive function, you can try calling

 process.nextTick(function(){calculate()}) 

Answer 2

Not surprisingly, a direct recursive call will lead to a stack overflow, however, it seems that frequent function calls will get node freezes (BTW, I don't know why this happens :().

For example, the following script freezes around 4k ~ 5k loops on my machine with a 1.6 GHz processor and 3.3 GB of memory, and node continues to swallow my available memory.

 var i = 0; function cal() { console.log(++i); process.nextTick(cal); } cal(); 

But if I changed process.nextTick(cal); on setTimeout(cal, 0); , everything will be fine.

As for your question, I think you can use something like setTimeout(calculate, 100) in your script to prevent a recursive call and postpone it a bit.