d4l3k/about.md

## about.md

      
    Raw
  

              about.md
            
          
    This is a gist with a set of helpful performance tricks and best practices that I've found on the internet.

  
## cockroachdb.md

      
    Raw
  

              cockroachdb.md
            
          
    cockroachdb

http://www.cockroachlabs.com/blog/how-to-optimize-garbage-collection-in-go/

  
## fasthttp.md

      
    Raw
  

              fasthttp.md
            
          
    fasthttp

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.
Verify your tests and production code under
race detector on a regular basis.

Tricks with []byte buffers

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

Standard Go functions accept nil buffers

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,
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)