I think there's a flaw in your methodology

[ryantate13]

I've set up a fork to demonstrate what I'm talking about. You can see it here:

https://github.com/ryantate13/php-node-bubblesort-test/

In my test runs PHP is consistently ~20x slower than Node. I set up a script to cycle through 100 test runs and take the min time of each set per platform.

If you clone my repo and run make test you can see it in action. PHP is v7.2.18, Node is v10.14.2.

time elapsed (nanoseconds) for php is 133,391,141
time elapsed (nanoseconds) for node is 7,014,987

[erkstruwe]

I assume that if you run the algorithm as a response to an HTTP request (the main use case of both PHP and Node.js) the results would be even more in favor of Node.js.

[tutume]

One small difference but that in a quick test shows that will impact a lot on the result is that on node, you are copying the value from the array to the function and on the php you are passing as reference.

you can see it here
https://repl.it/repls/FelineAccurateSpreadsheet

I found your git repo and know about it because I'm justing learning these differences and was reseaching for a better understanding. Hope that you help you too.

[jishi]

Not sure what the author is trying to prove, even in his own output in the Readme php is about 50x slower, 223ms vs 4ms?

[gitKearney]

@jishi the first test initially had only 12 elements. With 12 elements PHP was much faster

$ php bubble-sort-v2.php
0 seconds 0.000087 microseconds

$ node bubble-sort-v2.js
0 seconds 0.409986 milliseconds

As the tests get larger, PHP execution time increases

[gitKearney]

but that in a quick test shows that will impact a lot

Thanks for this! I was under the impression that arrays in JS were passed by reference as well.

@tutume this example shows that array's are passed by reference, no?

const doSomething = (array) => {
    array.push(12);
}

const myArray = [1, 2, 3, 4, ];
doSomething(myArray);
console.log(myArray);

[gitKearney]

@ryantate13 Yes, I've updated my test to use an array with 4096 elements. With this number, the V8 engine is much faster than PHP.

When the array is less than 220 items, though, my tests show PHP to be faster

[PHP] array contains 204 elements, execution time: 2.503891 ms
[V8] array contains 204 elements, execution time: 2.550107 ms

[chemiu]

Do the measurements measure the entire script or just the sorting function?

[ryantate13]

@tutume Arrays are always pass by reference in JS, it's only in PHP that they are value types

@chemiu Performance metrics only measure the execution time of the bubbleSort function

@gitKearney Agreed, array size definitely has an impact and similar to what you've found, in the latest version of my fork, I noticed that Node overtakes PHP in performance somewhere between 200-300 elements. I think that what we're seeing here is Node getting a chance to optimize hot paths with the greater number of elements. Switching to PHP 7.3 also helps bridge the gap quite a bit, ~10x performance difference at 1000 elements vs ~20x. What I found more interesting is that, drawing inspiration from @erkstruwe, I set up a benchmark for HTTP performance as well and php-fpm/nginx outperforms (single-threaded) Node almost by an order of magnitude. I think that's because Nginx is handling multiple worker processes in parallel. A more fair test would be to have the Node server running in cluster mode and see what kind of impact that would have.

CLI Test Results:

list size: 100
time elapsed (nanoseconds) for php is 690,329
time elapsed (nanoseconds) for node is 1,424,127
list size: 200
time elapsed (nanoseconds) for php is 2,706,607
time elapsed (nanoseconds) for node is 4,992,812
list size: 300
time elapsed (nanoseconds) for php is 6,179,346
time elapsed (nanoseconds) for node is 5,163,362
list size: 400
time elapsed (nanoseconds) for php is 12,378,367
time elapsed (nanoseconds) for node is 5,389,730
list size: 500
time elapsed (nanoseconds) for php is 17,650,035
time elapsed (nanoseconds) for node is 5,513,095
list size: 600
time elapsed (nanoseconds) for php is 25,876,427
time elapsed (nanoseconds) for node is 5,850,769
list size: 700
time elapsed (nanoseconds) for php is 36,529,920
time elapsed (nanoseconds) for node is 6,081,779
list size: 800
time elapsed (nanoseconds) for php is 44,227,545
time elapsed (nanoseconds) for node is 6,228,818
list size: 900
time elapsed (nanoseconds) for php is 57,408,295
time elapsed (nanoseconds) for node is 6,694,652
list size: 1000
time elapsed (nanoseconds) for php is 72,854,544
time elapsed (nanoseconds) for node is 7,116,747

HTTP Test Results:

Server Software:        nginx/1.16.0
Server Hostname:        php
Server Port:            80

Document Path:          /
Document Length:        Variable

Concurrency Level:      10
Time taken for tests:   0.306 seconds
Complete requests:      1000
Failed requests:        0
Total transferred:      487000 bytes
Total body sent:        4020000
HTML transferred:       325000 bytes
Requests per second:    3270.65 [#/sec] (mean)
Time per request:       3.058 [ms] (mean)
Time per request:       0.306 [ms] (mean, across all concurrent requests)
Transfer rate:          1555.47 [Kbytes/sec] received
                        12839.84 kb/s sent
                        14395.31 kb/s total

Server Software:        
Server Hostname:        node
Server Port:            80

Document Path:          /
Document Length:        Variable

Concurrency Level:      10
Time taken for tests:   2.435 seconds
Complete requests:      1000
Failed requests:        0
Total transferred:      82000 bytes
Total body sent:        4021000
HTML transferred:       7000 bytes
Requests per second:    410.73 [#/sec] (mean)
Time per request:       24.347 [ms] (mean)
Time per request:       2.435 [ms] (mean, across all concurrent requests)
Transfer rate:          32.89 [Kbytes/sec] received
                        1612.85 kb/s sent
                        1645.74 kb/s total

[erkstruwe]

A more fair test would be to have the Node server running in cluster mode and see what kind of impact that would have.

That was indeed a quite "unfair" test because Node.js had to stick to a single CPU node here. I think it would only be "fair" if you also had nginx running in front of a node cluster (e. g. with http://pm2.keymetrics.io/).

[ryantate13]

That was indeed a quite "unfair" test because Node.js had to stick to a single CPU node here.

I agree and I'd be interested to see how Node performs with the extra workers. I found this interesting though, single threaded for each, concurrency level 1, 100 total requests, list size=100, the results are almost identical. The problem with the HTTP version is there's a lot more noise and I'm not sure if that's completely avoidable. We're not just testing the algorithm anymore. The implementation posts the list as JSON so there's de/serialization involved, the overhead of the protocol, etc. It wouldn't help really to stick Nginx in front of the pm2 cluster in the docker-compose setup because pm2 speaks http directly vs needing it for fpm. I'd just point the benchmarks straight at pm2 and skip the overhead. If I get some time I'll try setting that up and see what effect it has.

Server Software:        
Server Hostname:        node
Server Port:            80

Document Path:          /
Document Length:        Variable

Concurrency Level:      1
Time taken for tests:   0.082 seconds
Complete requests:      100
Failed requests:        0
Total transferred:      8006 bytes
Total body sent:        41900
HTML transferred:       506 bytes
Requests per second:    1221.17 [#/sec] (mean)
Time per request:       0.819 [ms] (mean)
Time per request:       0.819 [ms] (mean, across all concurrent requests)
Transfer rate:          95.48 [Kbytes/sec] received
                        499.68 kb/s sent
                        595.15 kb/s total

Server Software:        nginx/1.16.0
Server Hostname:        php
Server Port:            80

Document Path:          /
Document Length:        Variable

Concurrency Level:      1
Time taken for tests:   0.079 seconds
Complete requests:      100
Failed requests:        0
Total transferred:      48700 bytes
Total body sent:        41800
HTML transferred:       32500 bytes
Requests per second:    1271.54 [#/sec] (mean)
Time per request:       0.786 [ms] (mean)
Time per request:       0.786 [ms] (mean, across all concurrent requests)
Transfer rate:          604.72 [Kbytes/sec] received
                        519.05 kb/s sent
                        1123.77 kb/s total

[tutume]

but that in a quick test shows that will impact a lot

Thanks for this! I was under the impression that arrays in JS were passed by reference as well.

@tutume this example shows that array's are passed by reference, no?

const doSomething = (array) => {
    array.push(12);
}

const myArray = [1, 2, 3, 4, ];
doSomething(myArray);
console.log(myArray);

Well, I probabily need to learn much more, hehe. Sorry for that.

I know it has nothing to do with the code discussed here, but I'm trying to understand it as I understood wrong how this value/function works.

Could someone explain why this in this example the value doesn't change outside the function?

const doChange = (param) => {
    console.log(`Before: ${param}`)
    param = 'Changed'
}

let myVal = 'By Value'
doChange(myVal)
console.log(`After: ${myVal}\n`)

// result:
// Before: By Value
// After: By Value