I am perplexed by the lack of significant performance variation between JS and Go in my specific situation

Question

I am perplexed by the lack of significant performance variation between JS and Go in my specific situation

After working on the Project Euler problem #12, focusing on divisors and triangle numbers, I successfully solved it using both Go and JavaScript. Surprisingly, despite my assumption that the Go code would be much faster due to its building process compared to the runtime execution of JS, there were situations where the JS code outperformed the Go code.

Here is a snippet of the code I used:

https://gist.github.com/noraesae/675e40477e177f9f63f9

The test was conducted on my MacBook, which has the following specifications:

Processor: 2.6 GHz Intel Core i5
Memory: 8 GB 1600 MHz DDR3

I executed the code with the following commands:

$ #js
$ node euler12.js

$ #go
$ go build euler12.go
$ ./euler12

I am puzzled by the fact that there was no significant difference in performance between the two languages. Could there be something wrong with my approach? If not, what could explain the lack of disparity in speed? Interestingly, when comparing Go to Python, there was a notable gap in performance. Any insights would be greatly appreciated. Thank you.

javascript performance go

Answer 1

Answer №1

It's quite intriguing that, on my MacBook Pro from late 2013 with an i7 processor running at 2.3GHz, the JavaScript code outperforms the Go code:

JavaScript:

time node test.js
842161320

real    0m4.437s
user    0m4.900s
sys     0m0.150s

Go:

time GOMAXPROCS=8 ./test
842161320

real    0m7.345s
user    0m7.470s
sys     0m0.010s

However, with a swift optimization of the Go code:

Go:

time GOMAXPROCS=8 ./test
842161320

real    0m1.760s
user    0m11.610s
sys     0m0.230s

The optimization I implemented may seem simplistic: parallelize the computation process:

package main

import (
        "fmt"
        "os"
        "runtime"
)

func numberOfDivisors(n int64) int64 {
        var result int64

        var i int64 = 1
        for true {
                if n%i == 0 {
                        opposite := n / i
                        if opposite == i {
                                result++
                                return result
                        } else if opposite > i {
                                result += 2
                        } else {
                                return result
                        }
                }
                i++
        }
        return result
}

func main() {
        var acc int64
        var i int64 = 1

        maxRoutines := runtime.NumCPU()
        c := make(chan struct{}, maxRoutines)
        for i := 0; i < maxRoutines; i++ {
                c <- struct{}{}
        }
        for true {
                <-c
                acc += i
                go func(acc int64) {
                        defer func() { c <- struct{}{} }()
                        if numberOfDivisors(acc) > 1000 {
                                fmt.Println(acc)
                                os.Exit(0)
                        }
                }(acc)
                i++
        }
}

Answer 2

It's quite intriguing that, on my MacBook Pro from late 2013 with an i7 processor running at 2.3GHz, the JavaScript code outperforms the Go code:

JavaScript:

time node test.js
842161320

real    0m4.437s
user    0m4.900s
sys     0m0.150s

Go:

time GOMAXPROCS=8 ./test
842161320

real    0m7.345s
user    0m7.470s
sys     0m0.010s

However, with a swift optimization of the Go code:

Go:

time GOMAXPROCS=8 ./test
842161320

real    0m1.760s
user    0m11.610s
sys     0m0.230s

The optimization I implemented may seem simplistic: parallelize the computation process:

package main

import (
        "fmt"
        "os"
        "runtime"
)

func numberOfDivisors(n int64) int64 {
        var result int64

        var i int64 = 1
        for true {
                if n%i == 0 {
                        opposite := n / i
                        if opposite == i {
                                result++
                                return result
                        } else if opposite > i {
                                result += 2
                        } else {
                                return result
                        }
                }
                i++
        }
        return result
}

func main() {
        var acc int64
        var i int64 = 1

        maxRoutines := runtime.NumCPU()
        c := make(chan struct{}, maxRoutines)
        for i := 0; i < maxRoutines; i++ {
                c <- struct{}{}
        }
        for true {
                <-c
                acc += i
                go func(acc int64) {
                        defer func() { c <- struct{}{} }()
                        if numberOfDivisors(acc) > 1000 {
                                fmt.Println(acc)
                                os.Exit(0)
                        }
                }(acc)
                i++
        }
}

I am perplexed by the lack of significant performance variation between JS and Go in my specific situation

Answer №1

Similar questions

Utilizing a custom element as a dropdown button in React Bootstrap: A guide

Retrieve information from XML using jQuery

Pushing state history causes browser back and forward button failure

Showcasing all products via the terminal using the Mailchimp API in JavaScript

The back div is not retained on the second animation when flipping the card

Rendering a dynamic list of asynchronous components in Vue 3, with support for extension

Display numeric data when hovering over circles in the Google Maps API using Javascript

Issue with React hooks: Callback functions from library events (FabricJS) not receiving the updated state values

What methods do web browsers use to detect when a user has viewed a custom image on a webpage?

Utilizing Rails for dynamic form validation with AJAX

The ajax function is malfunctioning when called from an external JavaScript file

Comparing a series of smaller strings to a larger string for testing purposes

The CanvasJS column chart is failing to render data from a JSON string

When sending multiple JSON objects in an HTTP POST request to an ASP.NET MVC controller action, they may not be properly bound

Unable to retrieve values while mapping in next.js / react due to access restrictions

What is the best way to customize a component in a view?

Data of an object disappears when it is passed to Meteor.call

What are the steps to approve an Amazon Pay request for retrieving a "get checkout session"?

User class instantiation in livequery is initiated

Leveraging jQuery's .animate method to create engaging search box animations