From today series of #golang proposals regarding changes in runtime, compiler and all this strange stuff will be posted here.

The first one in the series: Create an undefined internal calling convention (by Austin Clements) https://github.com/golang/proposal/blob/master/design/27539-internal-abi.md

#golang performance tooling tip:

go tool pprof -base=https://old.prof https://new.prof

See the difference (subtraction) between the profiles. Useful to spot what piece of code to blame for a performance regression.

Courtesy of Keith: https://golang.org/214818

Original: https://twitter.com/mvdan_/status/1217313825600364544

Escape from Escape Analysis of #golang Sounds pretty interesting!

For the code, the heap allocation -8.88%, the heap usage -8.78%. Time consumption -9.48%, cumulative time of GC pause -5.64%.

Paper https://www.wingtecher.com/themes/WingTecherResearch/assets/papers/ICSE20.pdf

Code https://github.com/wangcong15/escape-from-escape-analysis-of-golang

Export data, the secret of #golang fast builds

by twitter.com/jayconrod https://jayconrod.com/posts/112/export-data--the-secret-of-go-s-fast-builds

Wanna know how signals are handled by #golang runtime? Check this one by twitter.com/blanchonvincent

https://medium.com/a-journey-with-go/go-gsignal-master-of-signals-329f7ff39391

Understand unsafe in #golang

https://www.pixelstech.net/article/1584241521-Understand-unsafe-in-GoLang

List of #Awesome #golang performance tools and libs.
https://github.com/cristaloleg/awesome-go-perf

Feel free to submit more!

(and sorry for a long break:)

Old one, but still a good one.

How #golang map are implemented? by twitter.com/davecheney

https://dave.cheney.net/2018/05/29/how-the-go-runtime-implements-maps-efficiently-without-generics

What is a goroutine? And what is their size? by twitter.com/tpaschalis_ #golang

https://tpaschalis.github.io/goroutines-size/

io_uring using #golang (liburing and CGo, to be exact)

by Agniva De Sarker https://github.com/agnivade (from twitter.com/Mattermost)

https://developers.mattermost.com/blog/hands-on-iouring-go/

Also don't forget to star pure Go solution https://github.com/hodgesds/iouring-go
(but hopefully https://github.com/golang/go/issues/31908 will be implemented in std)

Understanding CPU caches and whole CPU architecture with #golang by twitter.com/teivah

By the way, pretty beautiful illustrations!

https://medium.com/@teivah/go-and-cpu-caches-af5d32cc5592

A sampling Go profiler that allows you to analyze On-CPU as well as Off-CPU (e.g. I/O) time together.

https://github.com/felixge/fgprof by twitter.com/felixge

And it's literally under 100 lines! Amazing!

Building a high performance #golang JSON parser by twitter.com/davecheney

https://dave.cheney.net/high-performance-json.html

A Tale of Breadth-First Search by twitter.com/egonelbre at twitter.com/gopherconeu #golang

https://youtu.be/ulSlF2Phecg?list=PLtoVuM73AmsKnUvoFizEmvWo0BbegkSIG

Proposal: Register-based #golang calling convention

https://go.googlesource.com/proposal/+/refs/changes/78/248178/1/design/40724-register-calling.md

Short note on #golang alloc size classes by twitter.com/offbymany

https://commaok.xyz/post/discovering-size-classes/

#golang Goroutine lifecycle by https://github.com/jcorbin

Writing this issue out of the @GopherCon 2019 contribution workshop (additional kudos to @golang workshops!)
(from issue https://github.com/golang/go/issues/33322 )

What a beautiful thing! In #golang 1.16 you can track how much time is spent in init() funcs! what a nice thing to have!

https://github.com/golang/go/issues/41378

proposal: cmd/compile: switch to a register-based calling convention for #golang functions

Preliminary experiments indicate this will achieve at least a 5–10% throughput improvement across a range of applications

is accepted! 🚀

https://go.googlesource.com/proposal/+/master/design/40724-register-calling.md

https://github.com/golang/go/issues/40724

More #golang awesomness! Happening in 1.16 🎉

Go 1.16 will include an early devirtualization pass, which allows better escape analysis of interface method calls (i.e., fewer heap allocations) when the compiler can see the interface always has a known concrete type.

https://github.com/golang/go/issues/33160

https://twitter.com/mdempsky/status/1321894360116420608

WAAAAT #golang benchmarks on new @apple M1

https://roland.zone/m1-go-benchmarks/