fasthttp clone

Sergio VS 017f0aa09d fix: reset request after reset user values on keep-alive connections (#1162) 1 week ago
.github 46d92356a8 Check go fmt during lint (#1097) 2 months ago
examples fbe6a2d470 Add fasthttp.GenerateTestCertificate and use in tests 10 months ago
expvarhandler 9f2c63676d Lower go test time 5 months ago
fasthttpadaptor 9f2c63676d Lower go test time 5 months ago
fasthttpproxy 0263cae5a2 Fix FasthttpSocksDialer example 3 months ago
fasthttputil 9f2c63676d Lower go test time 5 months ago
fuzzit ba401075d3 compatible with new build tag (#1087) 3 months ago
pprofhandler 33b80a5951 Add support for named profiles like heap, goroutine, threadcreate, allocs, block, and mutex. 3 years ago
prefork 9f2c63676d Lower go test time 5 months ago
reuseport ba401075d3 compatible with new build tag (#1087) 3 months ago
stackless 9f2c63676d Lower go test time 5 months ago
testdata d53df67945 Fix Content-Type bug in FS 3 years ago
.gitignore d9c75732a6 improve invalidStatusLine by appending a `[]byte` directly (#1086) 3 months ago
LICENSE 0724b3e064 Update LICENSE formatting 1 year ago
README.md c078a9d550 Add string and bytes buffer convert trick in README (#1151) 3 weeks ago
SECURITY.md 5ce12a8e78 oss-security got new email 1 year ago
TODO 22c9594090 Added PipelineClient for issuing pipelined requests to the server 5 years ago
allocation_test.go 542a203b42 Properly parse URI 2 months ago
args.go ffab77a59d Improve return value reusability documentation 2 months ago
args_test.go 4e63057c0f Make argsKV more predictable 11 months ago
args_timing_test.go 91f896309a Added benchmark for Args.Peek() 6 years ago
brotli.go 339ad36634 Add Brotli support 1 year ago
brotli_test.go 339ad36634 Add Brotli support 1 year ago
bytesconv.go 6006c8761d chore (#1137) 1 month ago
bytesconv_32.go ba401075d3 compatible with new build tag (#1087) 3 months ago
bytesconv_32_test.go ba401075d3 compatible with new build tag (#1087) 3 months ago
bytesconv_64.go ba401075d3 compatible with new build tag (#1087) 3 months ago
bytesconv_64_test.go ba401075d3 compatible with new build tag (#1087) 3 months ago
bytesconv_table.go af531ad4c0 Move comment to now show up on godoc 2 years ago
bytesconv_table_gen.go ba401075d3 compatible with new build tag (#1087) 3 months ago
bytesconv_test.go 707b1c1917 Format errors (#679) 2 years ago
bytesconv_timing_test.go 32793db72d Run golangci-lint using a Github Action 2 years ago
client.go f7c354c760 Fix race condition in Client.mCleaner 3 weeks ago
client_example_test.go 215f1d2caf Added an example for HostClient 6 years ago
client_test.go a50f59be52 Increase various test timeouts 3 months ago
client_timing_test.go 32793db72d Run golangci-lint using a Github Action 2 years ago
client_timing_wait_test.go ba401075d3 compatible with new build tag (#1087) 3 months ago
coarseTime.go ef10ed05a3 deprecate CoarseTime and replace it with a shortcut implementation 3 years ago
coarseTime_test.go 32c72cde80 Export CoarseTimeNow and clarify that RequestCtx.Time() and RequestCtx.ConnTime() return time truncated to a second 4 years ago
compress.go 0880335533 Update compress.go (#978) 9 months ago
compress_test.go c3d82ca3a4 Speed up testing by running tests in parallel 2 years ago
cookie.go ffab77a59d Improve return value reusability documentation 2 months ago
cookie_test.go 9f2c63676d Lower go test time 5 months ago
cookie_timing_test.go 236d4bd461 Added Cookie.ParseBytes to be consistent with Args 6 years ago
doc.go 5f6439b6df Remove wrong documentation 3 years ago
fs.go 931d0a4523 Fix lint 1 month ago
fs_example_test.go e0568fa3fb Fixed a typo 6 years ago
fs_handler_example_test.go f8ff9270f2 Added an example for FS 6 years ago
fs_test.go c15e642a16 Don't run all race tests on windows (#1143) 1 month ago
go.mod 97e1319927 Update compress (#1069) 3 months ago
go.sum 97e1319927 Update compress (#1069) 3 months ago
header.go 2ca01c7efb fix: Status Line parsing and writing (#1135) 3 weeks ago
header_regression_test.go 39dd1045bb Allow a body for GET requests (#703) 2 years ago
header_test.go 2ca01c7efb fix: Status Line parsing and writing (#1135) 3 weeks ago
header_timing_test.go f0a21893b9 feat: improve IsMethod (#1088) 2 months ago
headers.go 38e068a51c Fix XHR Typo (#735) 1 year ago
http.go 8febad0797 http.go: Request.SetURI() (Fix #1141) (#1148) 3 weeks ago
http_test.go 8febad0797 http.go: Request.SetURI() (Fix #1141) (#1148) 3 weeks ago
lbclient.go 32793db72d Run golangci-lint using a Github Action 2 years ago
lbclient_example_test.go a965b01816 Added an example for LBClient 5 years ago
methods.go f544170d63 Added methods constants (#567) 2 years ago
nocopy.go 32793db72d Run golangci-lint using a Github Action 2 years ago
peripconn.go 57cbe65ddc scalability improvement: use per-server peripconn pool 5 years ago
peripconn_test.go c3d82ca3a4 Speed up testing by running tests in parallel 2 years ago
requestctx_setbodystreamwriter_example_test.go 05949704db Issue #78: Added an example for RequestCtx.SetBodyStreamWriter 5 years ago
server.go 017f0aa09d fix: reset request after reset user values on keep-alive connections (#1162) 1 week ago
server_example_test.go 6a8707cd8d Import fasthttp in server examples 6 years ago
server_test.go 017f0aa09d fix: reset request after reset user values on keep-alive connections (#1162) 1 week ago
server_timing_test.go 021c821992 Fix NetHTTPServerGet benchmarks 1 year ago
status.go 2ca01c7efb fix: Status Line parsing and writing (#1135) 3 weeks ago
status_test.go 2ca01c7efb fix: Status Line parsing and writing (#1135) 3 weeks ago
status_timing_test.go 2ca01c7efb fix: Status Line parsing and writing (#1135) 3 weeks ago
stream.go 886e541160 Removed 'recover-from-panic' band-aids. 5 years ago
stream_test.go 32793db72d Run golangci-lint using a Github Action 2 years ago
stream_timing_test.go ce9d1d2224 Use fasthttp.PipeConns instead of io.Pipe in StreamReader 5 years ago
streaming.go 19fcd40863 Fix chunked streaming (#1015) 7 months ago
streaming_test.go 9f2c63676d Lower go test time 5 months ago
strings.go 46d92356a8 Check go fmt during lint (#1097) 2 months ago
tcpdialer.go 6d4db9bb7e Fix race condition in getTCPAddrs 1 month ago
timer.go 627d63dd25 change timer to public api #525 (#527) 2 years ago
tls.go fbe6a2d470 Add fasthttp.GenerateTestCertificate and use in tests 10 months ago
uri.go 3ff6aaa591 uri: isHttps() and isHttp() (#1150) 3 weeks ago
uri_test.go 3ff6aaa591 uri: isHttps() and isHttp() (#1150) 3 weeks ago
uri_timing_test.go 34a61fe63f Update linting (#851) 1 year ago
uri_unix.go ba401075d3 compatible with new build tag (#1087) 3 months ago
uri_windows.go ba401075d3 compatible with new build tag (#1087) 3 months ago
uri_windows_test.go ba401075d3 compatible with new build tag (#1087) 3 months ago
userdata.go 7fdd5261e8 feat: a new userData API `Remove` (#1117) 1 month ago
userdata_test.go 7fdd5261e8 feat: a new userData API `Remove` (#1117) 1 month ago
userdata_timing_test.go b00a213a93 Moved ctx.UserValue from standard map to custom userData. This should improve its' performance for common case when ctx contains up to 10 user values 6 years ago
workerpool.go 9f11af2968 Make several optimizations to worker pool (#680) 2 years ago
workerpool_test.go a50f59be52 Increase various test timeouts 3 months ago

README.md

fasthttp GoDoc Go Report

Fast HTTP implementation for Go.

fasthttp might not be for you!

fasthttp was design for some high performance edge cases. Unless your server/client needs to handle thousands of small to medium requests per seconds and needs a consistent low millisecond response time fasthttp might not be for you. For most cases net/http is much better as it's easier to use and can handle more cases. For most cases you won't even notice the performance difference.

General info and links

Currently fasthttp is successfully used by VertaMedia in a production serving up to 200K rps from more than 1.5M concurrent keep-alive connections per physical server.

TechEmpower Benchmark round 19 results

Server Benchmarks

Client Benchmarks

Install

Documentation

Examples from docs

Code examples

Awesome fasthttp tools

Switching from net/http to fasthttp

Fasthttp best practices

Tricks with byte buffers

Related projects

FAQ

HTTP server performance comparison with net/http

In short, fasthttp server is up to 10 times faster than net/http. Below are benchmark results.

GOMAXPROCS=1

net/http server:

$ GOMAXPROCS=1 go test -bench=NetHTTPServerGet -benchmem -benchtime=10s
BenchmarkNetHTTPServerGet1ReqPerConn                	 1000000	     12052 ns/op	    2297 B/op	      29 allocs/op
BenchmarkNetHTTPServerGet2ReqPerConn                	 1000000	     12278 ns/op	    2327 B/op	      24 allocs/op
BenchmarkNetHTTPServerGet10ReqPerConn               	 2000000	      8903 ns/op	    2112 B/op	      19 allocs/op
BenchmarkNetHTTPServerGet10KReqPerConn              	 2000000	      8451 ns/op	    2058 B/op	      18 allocs/op
BenchmarkNetHTTPServerGet1ReqPerConn10KClients      	  500000	     26733 ns/op	    3229 B/op	      29 allocs/op
BenchmarkNetHTTPServerGet2ReqPerConn10KClients      	 1000000	     23351 ns/op	    3211 B/op	      24 allocs/op
BenchmarkNetHTTPServerGet10ReqPerConn10KClients     	 1000000	     13390 ns/op	    2483 B/op	      19 allocs/op
BenchmarkNetHTTPServerGet100ReqPerConn10KClients    	 1000000	     13484 ns/op	    2171 B/op	      18 allocs/op

fasthttp server:

$ GOMAXPROCS=1 go test -bench=kServerGet -benchmem -benchtime=10s
BenchmarkServerGet1ReqPerConn                       	10000000	      1559 ns/op	       0 B/op	       0 allocs/op
BenchmarkServerGet2ReqPerConn                       	10000000	      1248 ns/op	       0 B/op	       0 allocs/op
BenchmarkServerGet10ReqPerConn                      	20000000	       797 ns/op	       0 B/op	       0 allocs/op
BenchmarkServerGet10KReqPerConn                     	20000000	       716 ns/op	       0 B/op	       0 allocs/op
BenchmarkServerGet1ReqPerConn10KClients             	10000000	      1974 ns/op	       0 B/op	       0 allocs/op
BenchmarkServerGet2ReqPerConn10KClients             	10000000	      1352 ns/op	       0 B/op	       0 allocs/op
BenchmarkServerGet10ReqPerConn10KClients            	20000000	       789 ns/op	       2 B/op	       0 allocs/op
BenchmarkServerGet100ReqPerConn10KClients           	20000000	       604 ns/op	       0 B/op	       0 allocs/op

GOMAXPROCS=4

net/http server:

$ GOMAXPROCS=4 go test -bench=NetHTTPServerGet -benchmem -benchtime=10s
BenchmarkNetHTTPServerGet1ReqPerConn-4                  	 3000000	      4529 ns/op	    2389 B/op	      29 allocs/op
BenchmarkNetHTTPServerGet2ReqPerConn-4                  	 5000000	      3896 ns/op	    2418 B/op	      24 allocs/op
BenchmarkNetHTTPServerGet10ReqPerConn-4                 	 5000000	      3145 ns/op	    2160 B/op	      19 allocs/op
BenchmarkNetHTTPServerGet10KReqPerConn-4                	 5000000	      3054 ns/op	    2065 B/op	      18 allocs/op
BenchmarkNetHTTPServerGet1ReqPerConn10KClients-4        	 1000000	     10321 ns/op	    3710 B/op	      30 allocs/op
BenchmarkNetHTTPServerGet2ReqPerConn10KClients-4        	 2000000	      7556 ns/op	    3296 B/op	      24 allocs/op
BenchmarkNetHTTPServerGet10ReqPerConn10KClients-4       	 5000000	      3905 ns/op	    2349 B/op	      19 allocs/op
BenchmarkNetHTTPServerGet100ReqPerConn10KClients-4      	 5000000	      3435 ns/op	    2130 B/op	      18 allocs/op

fasthttp server:

$ GOMAXPROCS=4 go test -bench=kServerGet -benchmem -benchtime=10s
BenchmarkServerGet1ReqPerConn-4                         	10000000	      1141 ns/op	       0 B/op	       0 allocs/op
BenchmarkServerGet2ReqPerConn-4                         	20000000	       707 ns/op	       0 B/op	       0 allocs/op
BenchmarkServerGet10ReqPerConn-4                        	30000000	       341 ns/op	       0 B/op	       0 allocs/op
BenchmarkServerGet10KReqPerConn-4                       	50000000	       310 ns/op	       0 B/op	       0 allocs/op
BenchmarkServerGet1ReqPerConn10KClients-4               	10000000	      1119 ns/op	       0 B/op	       0 allocs/op
BenchmarkServerGet2ReqPerConn10KClients-4               	20000000	       644 ns/op	       0 B/op	       0 allocs/op
BenchmarkServerGet10ReqPerConn10KClients-4              	30000000	       346 ns/op	       0 B/op	       0 allocs/op
BenchmarkServerGet100ReqPerConn10KClients-4             	50000000	       282 ns/op	       0 B/op	       0 allocs/op

HTTP client comparison with net/http

In short, fasthttp client is up to 10 times faster than net/http. Below are benchmark results.

GOMAXPROCS=1

net/http client:

$ GOMAXPROCS=1 go test -bench='HTTPClient(Do|GetEndToEnd)' -benchmem -benchtime=10s
BenchmarkNetHTTPClientDoFastServer                  	 1000000	     12567 ns/op	    2616 B/op	      35 allocs/op
BenchmarkNetHTTPClientGetEndToEnd1TCP               	  200000	     67030 ns/op	    5028 B/op	      56 allocs/op
BenchmarkNetHTTPClientGetEndToEnd10TCP              	  300000	     51098 ns/op	    5031 B/op	      56 allocs/op
BenchmarkNetHTTPClientGetEndToEnd100TCP             	  300000	     45096 ns/op	    5026 B/op	      55 allocs/op
BenchmarkNetHTTPClientGetEndToEnd1Inmemory          	  500000	     24779 ns/op	    5035 B/op	      57 allocs/op
BenchmarkNetHTTPClientGetEndToEnd10Inmemory         	 1000000	     26425 ns/op	    5035 B/op	      57 allocs/op
BenchmarkNetHTTPClientGetEndToEnd100Inmemory        	  500000	     28515 ns/op	    5045 B/op	      57 allocs/op
BenchmarkNetHTTPClientGetEndToEnd1000Inmemory       	  500000	     39511 ns/op	    5096 B/op	      56 allocs/op

fasthttp client:

$ GOMAXPROCS=1 go test -bench='kClient(Do|GetEndToEnd)' -benchmem -benchtime=10s
BenchmarkClientDoFastServer                         	20000000	       865 ns/op	       0 B/op	       0 allocs/op
BenchmarkClientGetEndToEnd1TCP                      	 1000000	     18711 ns/op	       0 B/op	       0 allocs/op
BenchmarkClientGetEndToEnd10TCP                     	 1000000	     14664 ns/op	       0 B/op	       0 allocs/op
BenchmarkClientGetEndToEnd100TCP                    	 1000000	     14043 ns/op	       1 B/op	       0 allocs/op
BenchmarkClientGetEndToEnd1Inmemory                 	 5000000	      3965 ns/op	       0 B/op	       0 allocs/op
BenchmarkClientGetEndToEnd10Inmemory                	 3000000	      4060 ns/op	       0 B/op	       0 allocs/op
BenchmarkClientGetEndToEnd100Inmemory               	 5000000	      3396 ns/op	       0 B/op	       0 allocs/op
BenchmarkClientGetEndToEnd1000Inmemory              	 5000000	      3306 ns/op	       2 B/op	       0 allocs/op

GOMAXPROCS=4

net/http client:

$ GOMAXPROCS=4 go test -bench='HTTPClient(Do|GetEndToEnd)' -benchmem -benchtime=10s
BenchmarkNetHTTPClientDoFastServer-4                    	 2000000	      8774 ns/op	    2619 B/op	      35 allocs/op
BenchmarkNetHTTPClientGetEndToEnd1TCP-4                 	  500000	     22951 ns/op	    5047 B/op	      56 allocs/op
BenchmarkNetHTTPClientGetEndToEnd10TCP-4                	 1000000	     19182 ns/op	    5037 B/op	      55 allocs/op
BenchmarkNetHTTPClientGetEndToEnd100TCP-4               	 1000000	     16535 ns/op	    5031 B/op	      55 allocs/op
BenchmarkNetHTTPClientGetEndToEnd1Inmemory-4            	 1000000	     14495 ns/op	    5038 B/op	      56 allocs/op
BenchmarkNetHTTPClientGetEndToEnd10Inmemory-4           	 1000000	     10237 ns/op	    5034 B/op	      56 allocs/op
BenchmarkNetHTTPClientGetEndToEnd100Inmemory-4          	 1000000	     10125 ns/op	    5045 B/op	      56 allocs/op
BenchmarkNetHTTPClientGetEndToEnd1000Inmemory-4         	 1000000	     11132 ns/op	    5136 B/op	      56 allocs/op

fasthttp client:

$ GOMAXPROCS=4 go test -bench='kClient(Do|GetEndToEnd)' -benchmem -benchtime=10s
BenchmarkClientDoFastServer-4                           	50000000	       397 ns/op	       0 B/op	       0 allocs/op
BenchmarkClientGetEndToEnd1TCP-4                        	 2000000	      7388 ns/op	       0 B/op	       0 allocs/op
BenchmarkClientGetEndToEnd10TCP-4                       	 2000000	      6689 ns/op	       0 B/op	       0 allocs/op
BenchmarkClientGetEndToEnd100TCP-4                      	 3000000	      4927 ns/op	       1 B/op	       0 allocs/op
BenchmarkClientGetEndToEnd1Inmemory-4                   	10000000	      1604 ns/op	       0 B/op	       0 allocs/op
BenchmarkClientGetEndToEnd10Inmemory-4                  	10000000	      1458 ns/op	       0 B/op	       0 allocs/op
BenchmarkClientGetEndToEnd100Inmemory-4                 	10000000	      1329 ns/op	       0 B/op	       0 allocs/op
BenchmarkClientGetEndToEnd1000Inmemory-4                	10000000	      1316 ns/op	       5 B/op	       0 allocs/op

Install

go get -u github.com/valyala/fasthttp

Switching from net/http to fasthttp

Unfortunately, fasthttp doesn't provide API identical to net/http. See the FAQ for details. There is net/http -> fasthttp handler converter, but it is better to write fasthttp request handlers by hand in order to use all of the fasthttp advantages (especially high performance :) ).

Important points:

  type MyHandler struct {
  	foobar string
  }

  // request handler in net/http style, i.e. method bound to MyHandler struct.
  func (h *MyHandler) HandleFastHTTP(ctx *fasthttp.RequestCtx) {
  	// notice that we may access MyHandler properties here - see h.foobar.
  	fmt.Fprintf(ctx, "Hello, world! Requested path is %q. Foobar is %q",
  		ctx.Path(), h.foobar)
  }

  // request handler in fasthttp style, i.e. just plain function.
  func fastHTTPHandler(ctx *fasthttp.RequestCtx) {
  	fmt.Fprintf(ctx, "Hi there! RequestURI is %q", ctx.RequestURI())
  }

  // pass bound struct method to fasthttp
  myHandler := &MyHandler{
  	foobar: "foobar",
  }
  fasthttp.ListenAndServe(":8080", myHandler.HandleFastHTTP)

  // pass plain function to fasthttp
  fasthttp.ListenAndServe(":8081", fastHTTPHandler)
  • The RequestHandler accepts only one argument - RequestCtx. It contains all the functionality required for http request processing and response writing. Below is an example of a simple request handler conversion from net/http to fasthttp.
  // net/http request handler
  requestHandler := func(w http.ResponseWriter, r *http.Request) {
  	switch r.URL.Path {
  	case "/foo":
  		fooHandler(w, r)
  	case "/bar":
  		barHandler(w, r)
  	default:
  		http.Error(w, "Unsupported path", http.StatusNotFound)
  	}
  }
  // the corresponding fasthttp request handler
  requestHandler := func(ctx *fasthttp.RequestCtx) {
  	switch string(ctx.Path()) {
  	case "/foo":
  		fooHandler(ctx)
  	case "/bar":
  		barHandler(ctx)
  	default:
  		ctx.Error("Unsupported path", fasthttp.StatusNotFound)
  	}
  }
  • Fasthttp allows setting response headers and writing response body in an arbitrary order. There is no 'headers first, then body' restriction like in net/http. The following code is valid for fasthttp:
  requestHandler := func(ctx *fasthttp.RequestCtx) {
  	// set some headers and status code first
  	ctx.SetContentType("foo/bar")
  	ctx.SetStatusCode(fasthttp.StatusOK)

  	// then write the first part of body
  	fmt.Fprintf(ctx, "this is the first part of body\n")

  	// then set more headers
  	ctx.Response.Header.Set("Foo-Bar", "baz")

  	// then write more body
  	fmt.Fprintf(ctx, "this is the second part of body\n")

  	// then override already written body
  	ctx.SetBody([]byte("this is completely new body contents"))

  	// then update status code
  	ctx.SetStatusCode(fasthttp.StatusNotFound)

  	// basically, anything may be updated many times before
  	// returning from RequestHandler.
  	//
  	// Unlike net/http fasthttp doesn't put response to the wire until
  	// returning from RequestHandler.
  }

Net/http code with simple ServeMux is trivially converted to fasthttp code:

  // net/http code

  m := &http.ServeMux{}
  m.HandleFunc("/foo", fooHandlerFunc)
  m.HandleFunc("/bar", barHandlerFunc)
  m.Handle("/baz", bazHandler)

  http.ListenAndServe(":80", m)
  // the corresponding fasthttp code
  m := func(ctx *fasthttp.RequestCtx) {
  	switch string(ctx.Path()) {
  	case "/foo":
  		fooHandlerFunc(ctx)
  	case "/bar":
  		barHandlerFunc(ctx)
  	case "/baz":
  		bazHandler.HandlerFunc(ctx)
  	default:
  		ctx.Error("not found", fasthttp.StatusNotFound)
  	}
  }

  fasthttp.ListenAndServe(":80", m)

Use this brilliant tool - race detector - for detecting and eliminating data races in your program. If you detected data race related to fasthttp in your program, then there is high probability you forgot calling TimeoutError before returning from RequestHandler.

Performance optimization tips for multi-core systems

  • Use reuseport listener.
  • Run a separate server instance per CPU core with GOMAXPROCS=1.
  • Pin each server instance to a separate CPU core using taskset.
  • Ensure the interrupts of multiqueue network card are evenly distributed between CPU cores. See this article for details.
  • Use the latest version of Go as each version contains performance improvements.

Fasthttp best practices

  • Do not allocate objects and []byte buffers - just reuse them as much as possible. Fasthttp API design encourages this.
  • sync.Pool is your best friend.
  • Profile your program in production. go tool pprof --alloc_objects your-program mem.pprof usually gives better insights for optimization opportunities than go tool pprof your-program cpu.pprof.
  • Write tests and benchmarks for hot paths.
  • Avoid conversion between []byte and string, since this may result in memory allocation+copy. Fasthttp API provides functions for both []byte and string - use these functions instead of converting manually between []byte and string. There are some exceptions - see this wiki page for more details.
  • Verify your tests and production code under race detector on a regular basis.
  • Prefer quicktemplate instead of html/template in your webserver.

Tricks with []byte buffers

The following tricks are used by fasthttp. Use them in your code too.

  • Standard Go functions accept nil buffers ```go var ( // both buffers are uninitialized dst []byte src []byte ) dst = append(dst, src...) // is legal if dst is nil and/or src is nil copy(dst, src) // is legal if dst is nil and/or src is nil (string(src) == "") // is true if src is nil (len(src) == 0) // is true if src is nil src = src[:0] // works like a charm with nil src

// this for loop doesn't panic if src is nil for i, ch := range src { doSomething(i, ch) }


So throw away nil checks for `[]byte` buffers from you code. For example,
```go
srcLen := 0
if src != nil {
	srcLen = len(src)
}

becomes

srcLen := len(src)
  • String may be appended to []byte buffer with append

    dst = append(dst, "foobar"...)
    
  • []byte buffer may be extended to its' capacity.

    buf := make([]byte, 100)
    a := buf[:10]  // len(a) == 10, cap(a) == 100.
    b := a[:100]  // is valid, since cap(a) == 100.
    
  • All fasthttp functions accept nil []byte buffer

    statusCode, body, err := fasthttp.Get(nil, "http://google.com/")
    uintBuf := fasthttp.AppendUint(nil, 1234)
    
  • String and []byte buffers may converted without memory allocations ```go func b2s(b []byte) string { return *(*string)(unsafe.Pointer(&b)) }

func s2b(s string) (b []byte) {

bh := (*reflect.SliceHeader)(unsafe.Pointer(&b))
sh := (*reflect.StringHeader)(unsafe.Pointer(&s))
bh.Data = sh.Data
bh.Cap = sh.Len
bh.Len = sh.Len
return b

} ```

Warning:

This is an unsafe way, the result string and []byte buffer share the same bytes.

Please make sure not to modify the bytes in the []byte buffer if the string still survives!

Related projects

  • fasthttp - various useful helpers for projects based on fasthttp.
  • fasthttp-routing - fast and powerful routing package for fasthttp servers.
  • http2 - HTTP/2 implementation for fasthttp.
  • router - a high performance fasthttp request router that scales well.
  • fastws - Bloatless WebSocket package made for fasthttp to handle Read/Write operations concurrently.
  • gramework - a web framework made by one of fasthttp maintainers
  • lu - a high performance go middleware web framework which is based on fasthttp.
  • websocket - Gorilla-based websocket implementation for fasthttp.
  • websocket - Event-based high-performance WebSocket library for zero-allocation websocket servers and clients.
  • fasthttpsession - a fast and powerful session package for fasthttp servers.
  • atreugo - High performance and extensible micro web framework with zero memory allocations in hot paths.
  • kratgo - Simple, lightweight and ultra-fast HTTP Cache to speed up your websites.
  • kit-plugins - go-kit transport implementation for fasthttp.
  • Fiber - An Expressjs inspired web framework running on Fasthttp
  • Gearbox - :gear: gearbox is a web framework written in Go with a focus on high performance and memory optimization

FAQ

  • Why creating yet another http package instead of optimizing net/http?

Because net/http API limits many optimization opportunities. For example:

  • net/http Request object lifetime isn't limited by request handler execution time. So the server must create a new request object per each request instead of reusing existing objects like fasthttp does.
  • net/http headers are stored in a map[string][]string. So the server must parse all the headers, convert them from []byte to string and put them into the map before calling user-provided request handler. This all requires unnecessary memory allocations avoided by fasthttp.
  • net/http client API requires creating a new response object per each request.

  • Why fasthttp API is incompatible with net/http?

Because net/http API limits many optimization opportunities. See the answer above for more details. Also certain net/http API parts are suboptimal for use:

HTTP/2.0 support is in progress. WebSockets has been done already. Third parties also may use RequestCtx.Hijack for implementing these goodies.

  • Are there known net/http advantages comparing to fasthttp?

Yes:

  • net/http supports HTTP/2.0 starting from go1.6.
  • net/http API is stable, while fasthttp API constantly evolves.
  • net/http handles more HTTP corner cases.
  • net/http can stream both request and response bodies
  • net/http can handle bigger bodies as it doesn't read the whole body into memory
  • net/http should contain less bugs, since it is used and tested by much wider audience.

  • Why fasthttp API prefers returning []byte instead of string?

Because []byte to string conversion isn't free - it requires memory allocation and copy. Feel free wrapping returned []byte result into string() if you prefer working with strings instead of byte slices. But be aware that this has non-zero overhead.

  • Which GO versions are supported by fasthttp?

Go 1.15.x. Older versions won't be supported.

  • Please provide real benchmark data and server information

See this issue.

  • Are there plans to add request routing to fasthttp?

There are no plans to add request routing into fasthttp. Use third-party routers and web frameworks with fasthttp support:

* [fasthttp-routing](https://github.com/qiangxue/fasthttp-routing)
* [router](https://github.com/fasthttp/router)
* [gramework](https://github.com/gramework/gramework)
* [lu](https://github.com/vincentLiuxiang/lu)
* [atreugo](https://github.com/savsgio/atreugo)
* [Fiber](https://github.com/gofiber/fiber)
* [Gearbox](https://github.com/gogearbox/gearbox)

See also this issue for more info.

  • I detected data race in fasthttp!

Cool! File a bug. But before doing this check the following in your code:

  • Make sure there are no references to RequestCtx or to its' members after returning from RequestHandler.
  • Make sure you call TimeoutError before returning from RequestHandler if there are references to RequestCtx or to its' members, which may be accessed by other goroutines.

  • I didn't find an answer for my question here

Try exploring these questions.