public
Last active

a proper fibonacci server in node. it will light up all your cores.

  • Download Gist
fib.js
JavaScript
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
var http = require('http')
var fork = require('child_process').fork;
 
function fib(n) {
if (n < 2) {
return 1;
} else {
return fib(n - 2) + fib(n - 1);
}
}
 
if (process.argv[2] == 'fib') {
var r = fib(40);
process.send({ result: r });
process.exit(0);
} else {
var server = http.createServer(function(req, res) {
var child = fork(__filename, [ 'fib' ]);
child.on('message', function(m) {
res.writeHead(200);
res.end(m.result + "\n");
});
});
server.listen(8000);
console.log("server online at http://localhost:8000/")
}

Great, but Im still curious to know why people tell you to make it :D

@DAddYE an article awhile back was written showcasing poor node.js performance compared to other languages using fibonacci calculation as the example. It was counter argued that the node.js server was poorly written, thus flawing the results. That would be my guess as to why @ry posted a proper one.

Here's a version that actually accounts for the input instead of always looking for "fib". Plus it makes the fib() function smaller: https://gist.github.com/2023979

Why don't you spin up a fixed-sized pool of long-lived worker processes that matches the number of CPU cores in the system?

By spawning new processes every time, at the very least you're making V8's JIT recompile the fibonacci function for every request, where that wouldn't be an issue with long-lived workers

@tarcieri yeah, that would be better

@ry that would be Apache.

in two dozen lines of javascript...

@ry : the threads_a_gogo version: https://gist.github.com/2031338 is only nineteen lines :

var http = require('http')
var pool = require('threads_a_gogo').createPool(5).all.eval(fib);

function fib (n) {
  if (n < 2) {
    return 1;
  } else {
    return fib(n - 2) + fib(n - 1);
  }
}

var server = http.createServer(function(req, res) {
  pool.any.eval('fib(40)', function (err, data) {
    res.writeHead(200);
    res.end(data + "\n");
  });
});
server.listen(8000);
console.log("server online at http://localhost:8000/")

@ry : And the threads_a_gogo version is almost twice as fast

$ time curl localhost:8000 //the threads_a_gogo version
165580141

real    0m2.550s
user    0m0.004s
sys 0m0.005s

$ time curl localhost:8000 // @ryah version
165580141

real    0m4.723s
user    0m0.004s
sys 0m0.004s

And uses less than 1/4th the memory:

ab -c 10 -n 10 http://127.0.0.1:8000 ->

@ry : 11 node processes, 22 threads
11.0+10.9+11.0+11.1+11.1+11.1+11.0+11.0+11.1+10.8+10.2= 120.3 MB
26.3 seconds
0.38 requests/s

threads_a_gogo: 1 node process, 12 threads
29.5 MB
13.2s
0.75 requests/s

@ry @xk

And here's a version using threads_a_gogo that uses 14 lines and accepts input: https://gist.github.com/2023979

Pass input via curl localhost:8000/# (i.e. curl localhost:8000/42)

OMG and heres a version with just one line of code

var http=require("http"),pool=require("threads_a_gogo").createPool(5).all.eval(fib);function fib(a){return 2>a?1:fib(a-2)+fib(a-1)}var server=http.createServer(function(a,b){pool.any.eval("fib(40)",function(a,c){b.writeHead(200);b.end(c+"\n")})});server.listen(8E3);console.log("server online at http://localhost:8000/");

Point being.. Lines of code are pointless.

oh god, node fanboys make me wanna puke :[

Please sign in to comment on this gist.

Something went wrong with that request. Please try again.