Awesome

go-router-benchmark

Compare the performance of routers built with golang.

Table of contents

• go-router-benchmark
• Table of contents
• Listed routers
• Motivation
• Benchmark test
  • Static route
  • Path parameter route
• Run benchmark tests
• Results
  • Static routes
    • time
    • nsop
    • bop
    • allocs
  • Pathparams routes
    • time
    • nsop
    • bop
    • allocs
• Conclusion
• Contribution
  • Want to add an HTTP Router ?
• Contribution
• Sponsor
• License
  • Author

Listed routers

• bmf-san/goblin
• julienschmidt/httprouter
• go-chi/chi
• gin-gonic/gin
• uptrace/bunrouter
• dimfeld/httptreemux
• beego/mux
• gorilla/mux
• nissy/bon
• naoina/denco
• labstack/echo
• gocraft/web
• vardius/gorouter
• go-ozzo/ozzo-routing
• lkeix/techbook13-sample

Since net/http#ServeMux does not have the capability to support path param route, only the static route test case is comparable.

Motivation

I have implemented a router called bmf-san/goblin, and I created this repository to compare it with other routers and get hints on how to improve bmf-san/goblin.

Another reason is that julienschmidt/go-http-routing-benchmark seems to have stopped being maintained, so I wanted to have a benchmarker for the router that I could manage myself.

Benchmark test

This benchmark tests is not a perfect comparison of HTTP Router performance. The reasons are as follows

• Not practical to cover all test cases because each HTTP Router has different specifications
• Performance may be unfairly evaluated depending on the routing test cases defined, since each HTTP Router has its own strengths and weaknesses depending on its data structures and algorithms.

Although the benchmark test is based on a specific case, it is possible to see some trends in performance differences.

Performance measurements will be made on the routing process of the HTTP Router. More specifically, we will test the ServeHTTP function of http#Handler.

We do not measure the performance of the process that defines the routing of the HTTP Router. The process of defining routing is the process of registering data for the routing process. For example, the code for net/http is as follows.

package main

import (
	"fmt"
	"net/http" )
)

func handler(w http.ResponseWriter, r *http.Request) {
	fmt.Fprint(w, "Hello World")
}

func main() {
	mux := http.NewServeMux()
	mux.HandleFunc("/", handler) // here
	ListenAndServe(":8080", mux)
}

We believe that the part that handles routing is called more often than the part that defines routing, and thus accounts for the majority of the HTTP Router's performance.

Static route

A static route is a route without variable parameters such as /foo/bar.

Static route measures performance by benchmarking routing tests with the following three input values.

• /
• /foo
• /foo/bar/baz/qux/quux
• /foo/bar/baz/qux/quux/corge/grault/garply/waldo/fred

Path parameter route

A path parameter route is a route with variable parameters such as /foo/:bar.

In path parameter route, we perform benchmark routing tests with the following three input values to measure the performance.

• /foo/:bar
• /foo/:bar/:baz/:qux/:quux/:corge
• /foo/:bar/:baz/:qux/:quux/:corge/:grault/:garply/:waldo/:fred/:plugh

Since different HTTP Routers have different ways of expressing parameters, there are several cases where another symbol is used in addition to :.

Run benchmark tests

Results

Benchmark results are published in a spreadsheet.

<Public>go-router-benchmark

Benchmark system

• go version: go1.22
• goos: darwin
• goarch: amd64
• pkg: github.com/go-router-benchmark
• cpu: VirtualApple @ 2.50GHz

Static routes

time

Graph - time

nsop

Graph - nsop

bop

Graph - bop

allocs

Graph - allocs

Pathparams routes

time

Graph - time

nsop

Graph - nsop

bop

Graph - bop

allocs

Graph - allocs

Conclusion

It can be seen that the HTTP Router with better performance has less performance degradation in each test case. This is a clear trend that shows that the implementation is optimized.

The better performing HTTP Route seems to employ a more sophisticated tree structure. Echo,gin,httprouter,bon,chi seem to adopt Radix tree (Patricia trie) and denco double array.

As for my implementation of goblin, it is a proprietary extension of the trie tree, which is not very well optimized, and I could clearly see that its performance is lower than the other HTTP Routers. (I will try my best to improve it...)

I don't think it is reasonable to assume that HTTP Router should not be adopted because of its seemingly poor performance in this benchmark result.

Some HTTP Routers are considered to be highly functional and easy to use, even if their performance is a little lower.

Some of the HTTP Routers listed here are no longer under development.

Since goblin has no plans to stop development for the time being, please try it if you like!

Contribution

We are always accepting issues, pull requests, and other requests and questions.

We look forward to your contribution！

Want to add an HTTP Router ?

If you have an HTTP Router or test case you would like to add, please send us an Issue or Pull Request.

If you are submitting an Issue, please tell us about the HTTP Router you would like to add.

If you are submitting a PullRequest, please add a test case. Reporting of benchmark runs is done by the owner, so you do not need to update the run results.

If you have any questions, you can ask them in Issue.

Contribution

Issues and Pull Requests are always welcome.

We would be happy to receive your contributions.

Please review the following documents before making a contribution.

CODE_OF_CONDUCT CONTRIBUTING

Sponsor

If you like it, I would be happy to have you sponsor it!

GitHub Sponsors - bmf-san

Or I would be happy to get a STAR.

It motivates me to keep up with ongoing maintenance :D

License

Based on the MIT License.

LICENSE

Author

bmf-san

• Email
  • bmf.infomation@gmail.com
• Blog
  • bmf-tech.com
• Twitter
  • bmf-san